File size: 6,208 Bytes
9f6a4bd
e99df76
691dc7c
8e438ab
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
691dc7c
8e438ab
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
691dc7c
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
8e438ab
 
 
 
 
 
 
691dc7c
8e438ab
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
691dc7c
8e438ab
 
 
691dc7c
8e438ab
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
from __future__ import annotations
"""FCC-owned coding conversation state and harness-neutral events."""

import time
from dataclasses import dataclass, field
from typing import Literal

from pydantic import BaseModel, ConfigDict, Field

from free_claude_code.core.json_types import JsonObject

type RunStatus = Literal[
    "preparing", "running", "stopping", "completed", "interrupted", "failed"
]
ACTIVE_RUN_STATUSES = frozenset({"preparing", "running", "stopping"})
type CodeMode = Literal["config", "ask", "auto_review", "full_access"]


def now_ms() -> int:
    return time.time_ns() // 1_000_000


class Record(BaseModel):
    model_config = ConfigDict(frozen=True, extra="forbid")


class CodeSession(Record):
    id: str
    cwd: str
    model: str
    reasoning_effort: str | None = None
    mode: CodeMode = "config"
    harness: Literal["codex"] = "codex"
    title: str = "New code session"
    auto_title: bool = True
    native_thread_id: str | None = None
    native_permission_defaults: JsonObject | None = None
    native_may_have_input: bool = False
    context_used_tokens: int | None = Field(default=None, ge=0)
    revision: int = 1
    status: Literal["ready", "deleting", "delete_uncertain"] = "ready"
    error: str | None = None
    created_at: int = Field(default_factory=now_ms)
    updated_at: int = Field(default_factory=now_ms)


class CodeRun(Record):
    id: str
    session_id: str
    text: str
    model: str
    reasoning_effort: str | None = None
    mode: CodeMode = "config"
    ordinal: int = 0
    status: RunStatus = "preparing"
    submission_started: bool = False
    native_turn_id: str | None = None
    stop_requested: bool = False
    error: str | None = None
    error_details: JsonObject = Field(default_factory=dict)
    created_at: int = Field(default_factory=now_ms)
    finished_at: int | None = None


class CodeItem(Record):
    id: str
    session_id: str
    sequence: int
    run_id: str
    native_turn_id: str | None = None
    native_item_id: str | None = None
    kind: str
    title: str = ""
    text: str = ""
    detail: str = ""
    complete: bool = False
    raw: JsonObject = Field(default_factory=dict)


class CodePrompt(Record):
    """Form and response state for the prompt CodeItem with the same session/id."""

    id: str
    session_id: str
    generation: str
    request_id: str | int
    native_turn_id: str | None = None
    native_item_id: str | None = None
    kind: str
    form: JsonObject
    raw: JsonObject
    status: Literal["pending", "answering", "resolved", "expired"] = "pending"
    response_id: str | None = None
    error: str | None = None


@dataclass(frozen=True, slots=True)
class CodeDetail:
    session: CodeSession
    run: CodeRun | None
    items: tuple[CodeItem, ...]
    prompts: tuple[CodePrompt, ...]
    epoch: str
    version: int
    cursor: int
    next_before: tuple[int, int] | None = None
    runs: tuple[CodeRun, ...] = ()
    active_prompt_ids: tuple[str, ...] = ()
    active_review_ids: tuple[str, ...] = ()


@dataclass(frozen=True, slots=True)
class CodeItemPage:
    items: tuple[CodeItem, ...]
    runs: tuple[CodeRun, ...]
    next_before: tuple[int, int] | None = None


@dataclass(frozen=True, slots=True)
class CodeHistory:
    session: CodeSession
    run: CodeRun | None
    items: tuple[CodeItem, ...]
    prompts: tuple[CodePrompt, ...]
    runs: tuple[CodeRun, ...]
    active_prompt_ids: tuple[str, ...]
    next_before: tuple[int, int] | None


@dataclass(frozen=True, slots=True)
class CodeExecutionSeed:
    session: CodeSession
    run: CodeRun | None
    sequence: int
    items: tuple[CodeItem, ...]
    prompts: tuple[CodePrompt, ...]
    runs: tuple[CodeRun, ...]


class CodeModel(Record):
    id: str
    display_name: str
    provider_id: str
    model_name: str
    reasoning_efforts: tuple[str, ...] = ()
    default_reasoning_effort: str | None = None
    context_window_tokens: int | None = Field(default=None, gt=0)


@dataclass(frozen=True, slots=True)
class CodeCatalog:
    default_model: str
    models: tuple[CodeModel, ...]


@dataclass(frozen=True, slots=True)
class CodePage:
    sessions: tuple[CodeSession, ...]
    next_cursor: tuple[int, str] | None = None


@dataclass(frozen=True, slots=True)
class ItemUpdate:
    turn_id: str
    item_id: str
    kind: str
    text: str = ""
    title: str = ""
    detail: str = ""
    raw: JsonObject = field(default_factory=dict)
    complete: bool = False
    client_id: str | None = None


@dataclass(frozen=True, slots=True)
class PromptRequest:
    request_id: str | int
    kind: str
    form: JsonObject
    raw: JsonObject
    turn_id: str | None = None
    item_id: str | None = None


@dataclass(frozen=True, slots=True)
class HarnessEvent:
    generation: str
    thread_id: str | None
    kind: Literal[
        "turn_started",
        "turn_completed",
        "item",
        "prompt",
        "resolved",
        "error",
        "notice",
        "context_usage",
        "closed",
    ]
    turn_id: str | None = None
    context_used_tokens: int | None = None
    item: ItemUpdate | None = None
    prompt: PromptRequest | None = None
    request_id: str | int | None = None
    status: RunStatus = "completed"
    message: str | None = None
    will_retry: bool = False
    error_details: JsonObject = field(default_factory=dict)
    raw: JsonObject = field(default_factory=dict)


@dataclass(frozen=True, slots=True)
class NativeTurn:
    id: str
    items: tuple[ItemUpdate, ...] = ()
    status: RunStatus = "completed"
    error: str | None = None
    error_details: JsonObject = field(default_factory=dict)


@dataclass(frozen=True, slots=True)
class NativeThread:
    id: str
    turns: tuple[NativeTurn, ...] = ()
    permission_defaults: JsonObject | None = None


class CodeError(Exception):
    """A user-facing failure of the coding session application."""


class CodeConflictError(CodeError):
    pass


class CodeNotFoundError(CodeError):
    pass


class CodeValidationError(CodeError):
    pass


class CodeUnavailableError(CodeError):
    pass


class NativeHistoryMissing(CodeNotFoundError):
    """The registered conversation no longer exists in native storage."""