File size: 8,127 Bytes
115b94d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
"""One-call advances, live decisions and saved-source repairs; no paid calls."""
import unittest
from src.tests.runtime.fixtures import setup,workspace,USER,OTHER,SOURCE
from src.modules.skill.domain.models import SkillError
from src.modules.context.service import ContextService


class OverdraftTests(unittest.TestCase):
    def active(self,folder,tokens=100):
        rt,request,model,_=setup(folder)
        request={**request,'budget_policy':{'mode':'one-call-overdraft-v1','increment':12000}}
        r=rt.create(USER,request,'overdraft-test-request')
        rt.store.mutate(r['id'],lambda r:r.update(status='running'))
        rt.store.mutate(r['id'],lambda r:r['budget'].update(max_tokens=tokens))
        return rt,r['id'],model

    def generate(self,rt,rid,kind='design',payload=None):
        return rt.llm.generate(rid,kind,payload or {'requirement':'完整原需求'},lambda:rt.store.get(rid)['cancel_requested'],32000)

    def test_one_advance_is_not_formal_budget_or_permission_for_more_calls(self):
        with workspace() as folder:
            rt,rid,model=self.active(folder)
            self.generate(rt,rid)
            r=rt.store.get(rid);p=r['budget_request']
            self.assertEqual(model.count,1);self.assertEqual(r['budget']['max_tokens'],100)
            self.assertEqual(p['after']['max_tokens'],12100)
            self.assertEqual(len(rt.store.calls(rid)),1)
            with self.assertRaises(SkillError) as err:self.generate(rt,rid)
            self.assertEqual(err.exception.code,'OVERDRAFT_APPROVAL_PENDING')
            self.assertEqual(model.count,1)

    def test_approval_during_reserved_call_never_enqueues_or_replays(self):
        with workspace() as folder:
            rt,rid,model=self.active(folder)
            decisions=[]
            def approve():
                r=rt.store.get(rid);p=r['budget_request']
                self.assertEqual(rt.store.calls(rid)[0]['state'],'reserved')
                with self.assertRaises(SkillError):rt.decide_budget(OTHER,rid,p['digest'],True)
                rt.store.mutate(rid,lambda r:r.update(audit_marker='stage continued'))
                decisions.append(rt.decide_budget(USER,rid,p['digest'],True,p['task_revision']))
                decisions.append(rt.decide_budget(USER,rid,p['digest'],True,p['task_revision']))
            model.hook=approve
            self.generate(rt,rid)
            self.assertTrue(decisions[0]['budget_decision_applied'])
            self.assertFalse(decisions[0]['budget_enqueue_required'])
            self.assertFalse(decisions[1]['budget_decision_applied'])
            self.assertEqual(rt.store.get(rid)['budget']['max_tokens'],12100)
            self.assertEqual(model.count,1)

    def test_decline_after_settlement_stops_but_keeps_charges(self):
        with workspace() as folder:
            rt,rid,model=self.active(folder);self.generate(rt,rid)
            rt.store.mutate(rid,lambda r:r.update(status='waiting_budget',error='OVERDRAFT_APPROVAL_PENDING'))
            p=rt.store.get(rid)['budget_request'];before=rt.store.calls(rid)
            r=rt.decide_budget(USER,rid,p['digest'],False)
            self.assertEqual(r['status'],'cancelled');self.assertTrue(r['cancel_requested'])
            self.assertEqual(r['budget']['max_tokens'],100)
            self.assertEqual(rt.store.calls(rid),before)
            with self.assertRaises(SkillError):self.generate(rt,rid)
            self.assertEqual(model.count,1)

    def test_approval_resumes_only_the_waiting_task_once(self):
        with workspace() as folder:
            rt,rid,model=self.active(folder);self.generate(rt,rid)
            rt.store.mutate(rid,lambda r:r.update(status='waiting_budget',error='OVERDRAFT_APPROVAL_PENDING'))
            p=rt.store.get(rid)['budget_request']
            result=rt.decide_budget(USER,rid,p['digest'],True)
            self.assertEqual(result['status'],'queued');self.assertTrue(result['budget_enqueue_required'])
            duplicate=rt.decide_budget(USER,rid,p['digest'],True)
            self.assertFalse(duplicate['budget_enqueue_required']);self.assertEqual(model.count,1)

    def test_unknown_call_is_never_replayed_even_if_debt_is_approved(self):
        with workspace() as folder:
            rt,rid,model=self.active(folder)
            def unknown():
                from src.modules.llm_gateway.service import ProviderFailure
                raise ProviderFailure('MODEL_RESULT_UNKNOWN')
            model.hook=unknown
            with self.assertRaises(SkillError):self.generate(rt,rid)
            p=rt.store.get(rid)['budget_request']
            rt.store.mutate(rid,lambda r:r.update(status='unknown',error='MODEL_RESULT_UNKNOWN'))
            result=rt.decide_budget(USER,rid,p['digest'],True)
            self.assertFalse(result['budget_enqueue_required']);self.assertEqual(result['status'],'unknown')
            with self.assertRaises(SkillError):self.generate(rt,rid)
            self.assertEqual(model.count,1);self.assertEqual(rt.store.calls(rid)[0]['state'],'unknown')

    def test_small_repair_output_gets_an_advance_instead_of_226_tokens(self):
        with workspace() as folder:
            rt,rid,model=self.active(folder,120000)
            self.generate(rt,rid,'repair',{'previous':SOURCE,'padding':'x'*29000})
            r=rt.store.get(rid);p=r['budget_request']
            self.assertGreaterEqual(p['output_reservation'],2048)
            self.assertEqual(p['stage_limit'],44000)
            self.assertEqual(r['budget']['max_tokens'],120000)

    def test_model_hard_window_does_not_allow_an_advance(self):
        with workspace() as folder:
            rt,rid,model=self.active(folder);model.context_window=1
            with self.assertRaises(SkillError):self.generate(rt,rid)
            self.assertIsNone(rt.store.get(rid).get('budget_request'))
            self.assertEqual(model.count,0);self.assertEqual(rt.store.calls(rid),[])

    def test_protocol_repair_preserves_full_page_and_uses_exact_java_edits(self):
        files={**SOURCE,'website/index.html':'<style>original</style><p>Full ERP</p>'}
        payload=ContextService.repair_inputs(files,'JAVA_TEST_FAILED',{'failures':[{'path':'/unknown'}]})
        self.assertEqual(payload['repair_scope']['mode'],'exact-edits')
        self.assertEqual(payload['previous'],SOURCE)
        self.assertIn('website/index.html',payload['repair_scope']['unchanged_files'])
        self.assertEqual(files['website/index.html'],'<style>original</style><p>Full ERP</p>')

    def test_call_limit_can_continue_in_approved_cycles_without_resetting_ledger(self):
        with workspace() as folder:
            rt,rid,model=self.active(folder,120000)
            rt.store.mutate(rid,lambda r:r['budget'].update(max_model_calls=1))
            self.generate(rt,rid)
            self.generate(rt,rid)
            p=rt.store.get(rid)['budget_request']
            self.assertEqual(p['after']['max_model_calls'],2)
            rt.decide_budget(USER,rid,p['digest'],True)
            self.generate(rt,rid)
            p=rt.store.get(rid)['budget_request']
            self.assertEqual(p['after']['max_model_calls'],3)
            rt.decide_budget(USER,rid,p['digest'],False)
            with self.assertRaises(SkillError):self.generate(rt,rid)
            self.assertEqual(model.count,3);self.assertEqual(len(rt.store.calls(rid)),3)

    def test_repair_limit_advance_is_disclosed_without_formally_raising_it(self):
        with workspace() as folder:
            rt,rid,model=self.active(folder,120000)
            before=rt.store.get(rid)['budget']['max_repairs']
            rt.store.mutate(rid,lambda r:r.update(status='repair_required',repairs=r['budget']['max_repairs'],error='JAVA_TEST_FAILED'))
            r=rt.repair(USER,rid)
            self.assertTrue(r['pending_repair_extension'])
            rt.store.mutate(rid,lambda r:r.update(status='running'))
            self.generate(rt,rid,'repair',{'previous':SOURCE})
            r=rt.store.get(rid)
            self.assertEqual(r['budget_request']['after']['max_repairs'],before+1)
            self.assertEqual(r['budget']['max_repairs'],before)