Spaces:
Running
Running
sync: upstream 9194f15 + custom addons (KeyRotator, RotatingChatTransport, sol/terra/luna, ScannerTrap, health, Py3.12 compat)
e99df76 Download src/free_claude_code/application/code_sessions/state.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 25 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/application/code_sessions/state.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/src/free_claude_code/application/code_sessions/state.py
-
curl -L -o state.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/application/code_sessions/state.py
25 kB
| from __future__ import annotations | |
| """Conversation rules and staged transcript values, without runtime I/O.""" | |
| import uuid | |
| from collections.abc import Mapping, Sequence | |
| from dataclasses import dataclass | |
| from types import MappingProxyType | |
| from typing import Literal, get_args | |
| from free_claude_code.core.json_types import JsonObject | |
| from .models import ( | |
| ACTIVE_RUN_STATUSES, | |
| CodeCatalog, | |
| CodeConflictError, | |
| CodeItem, | |
| CodeMode, | |
| CodeNotFoundError, | |
| CodePrompt, | |
| CodeRun, | |
| CodeSession, | |
| CodeUnavailableError, | |
| CodeValidationError, | |
| HarnessEvent, | |
| ItemUpdate, | |
| NativeThread, | |
| NativeTurn, | |
| PromptRequest, | |
| RunStatus, | |
| now_ms, | |
| ) | |
| class SessionProgress: | |
| """Candidate records saved together by the existing progress transaction.""" | |
| session: CodeSession | |
| run: CodeRun | None = None | |
| items: tuple[CodeItem, ...] = () | |
| prompts: tuple[CodePrompt, ...] = () | |
| class SessionState: | |
| def __init__( | |
| self, | |
| session: CodeSession, | |
| run: CodeRun | None, | |
| items: Sequence[CodeItem], | |
| prompts: Sequence[CodePrompt], | |
| runs: Sequence[CodeRun], | |
| *, | |
| sequence: int = 0, | |
| ) -> None: | |
| self._session = session | |
| self._run = run | |
| self._items = {item.id: item for item in items} | |
| self._prompts = {prompt.id: prompt for prompt in prompts} | |
| self._runs = {run.id: run for run in runs} | |
| self._sequence = max( | |
| sequence, max((item.sequence for item in items), default=0) | |
| ) | |
| self._dirty: set[str] = set() | |
| self._dirty_characters = 0 | |
| self._review_generations: dict[str, str] = {} | |
| def session(self) -> CodeSession: | |
| return self._session | |
| def run(self) -> CodeRun | None: | |
| return self._run | |
| def items(self) -> Mapping[str, CodeItem]: | |
| return MappingProxyType(self._items) | |
| def prompts(self) -> Mapping[str, CodePrompt]: | |
| return MappingProxyType(self._prompts) | |
| def runs(self) -> Mapping[str, CodeRun]: | |
| return MappingProxyType(self._runs) | |
| def busy(self) -> bool: | |
| return self._run is not None and self._run.status in ACTIVE_RUN_STATUSES | |
| def pending(self) -> bool: | |
| return any( | |
| prompt.status in {"pending", "answering"} | |
| for prompt in self._prompts.values() | |
| ) | |
| def pending_items(self) -> tuple[CodeItem, ...]: | |
| return tuple(self._items[item_id] for item_id in self._dirty) | |
| def dirty_characters(self) -> int: | |
| return self._dirty_characters | |
| def active_review_ids(self, generation: str | None) -> tuple[str, ...]: | |
| return tuple( | |
| item_id | |
| for item_id, observed in self._review_generations.items() | |
| if observed == generation | |
| ) | |
| def clear_review_liveness(self) -> bool: | |
| changed = bool(self._review_generations) | |
| self._review_generations.clear() | |
| return changed | |
| def accept_session(self, session: CodeSession) -> None: | |
| self._session = session | |
| def accept_admission( | |
| self, session: CodeSession, run: CodeRun, item: CodeItem | |
| ) -> None: | |
| self._session, self._run = session, run | |
| self._runs[run.id] = run | |
| self._items[item.id] = item | |
| self._sequence = item.sequence | |
| def accept_prompt(self, prompt: CodePrompt) -> None: | |
| self._prompts[prompt.id] = prompt | |
| def apply_progress(self, progress: SessionProgress) -> None: | |
| """Install acknowledged records; pending transcript writes stay explicit.""" | |
| self._session = progress.session | |
| if (run := progress.run) is not None: | |
| self._runs[run.id] = run | |
| if self._run is not None and self._run.id == run.id: | |
| self._run = run | |
| for item in progress.items: | |
| self._items[item.id] = item | |
| self._sequence = max(self._sequence, item.sequence) | |
| self._prompts.update((prompt.id, prompt) for prompt in progress.prompts) | |
| def acknowledge_flush(self) -> None: | |
| """The caller holds serialization through saving the complete pending set.""" | |
| self._dirty.clear() | |
| self._dirty_characters = 0 | |
| def remember_items( | |
| self, items: Sequence[CodeItem], runs: Sequence[CodeRun] | |
| ) -> None: | |
| """Load durable identities needed by one serialized operation.""" | |
| for item in items: | |
| self._items.setdefault(item.id, item) | |
| for run in runs: | |
| self._runs.setdefault(run.id, run) | |
| def prune(self) -> None: | |
| """Release acknowledged history after its events have been published.""" | |
| self._prompts = { | |
| key: prompt | |
| for key, prompt in self._prompts.items() | |
| if prompt.status in {"pending", "answering"} | |
| } | |
| pinned = self._dirty | self._prompts.keys() | self._review_generations.keys() | |
| self._items = { | |
| key: item | |
| for key, item in self._items.items() | |
| if key in pinned | |
| or (self.busy and self._run and item.run_id == self._run.id) | |
| } | |
| run_ids = {item.run_id for item in self._items.values()} | |
| if self._run is not None: | |
| run_ids.add(self._run.id) | |
| self._runs = {key: run for key, run in self._runs.items() if key in run_ids} | |
| def discard_deleted_history(self) -> None: | |
| self._items.clear() | |
| self._prompts.clear() | |
| self._run = None | |
| self._runs.clear() | |
| def check_revision(self, revision: int) -> None: | |
| if self._session.revision != revision: | |
| raise CodeConflictError( | |
| "This session changed. Refresh its state and try again." | |
| ) | |
| def check_editable(self, revision: int) -> None: | |
| if self._session.status != "ready": | |
| raise CodeConflictError( | |
| "This session changed. Refresh its state and try again." | |
| ) | |
| self.check_revision(revision) | |
| def validate_settings_fields(changes: JsonObject) -> None: | |
| if not changes or changes.keys() - { | |
| "title", | |
| "model", | |
| "reasoning_effort", | |
| "mode", | |
| }: | |
| raise CodeValidationError( | |
| "Choose a title, model, effort or mode to update." | |
| ) | |
| def settings_updates(self, changes: JsonObject) -> dict[str, object]: | |
| """Validate local rules before the application obtains model inventory.""" | |
| updates: dict[str, object] = dict(changes) | |
| if "title" in changes: | |
| title = changes["title"] | |
| if not isinstance(title, str) or not title.strip() or len(title) > 200: | |
| raise CodeValidationError("Enter a title of at most 200 characters.") | |
| updates.update(title=title.strip(), auto_title=False) | |
| if changes.keys() & {"model", "reasoning_effort", "mode"} and ( | |
| self.busy or self.pending | |
| ): | |
| raise CodeConflictError( | |
| "Finish this turn and its prompts before changing settings." | |
| ) | |
| if "mode" in changes and changes["mode"] not in get_args(CodeMode.__value__): | |
| raise CodeValidationError("Choose an available permission mode.") | |
| return updates | |
| def prepare_settings( | |
| self, updates: dict[str, object], catalog: CodeCatalog | None | |
| ) -> CodeSession: | |
| updates = dict(updates) | |
| if updates.keys() & {"model", "reasoning_effort"}: | |
| assert catalog is not None | |
| model = updates.get("model", self._session.model) | |
| entry = next((entry for entry in catalog.models if entry.id == model), None) | |
| if entry is None: | |
| raise CodeValidationError( | |
| "This model is unavailable. Choose another model." | |
| ) | |
| effort = updates.get("reasoning_effort", self._session.reasoning_effort) | |
| if ( | |
| "reasoning_effort" not in updates | |
| and model != self._session.model | |
| and effort not in entry.reasoning_efforts | |
| ): | |
| effort = None | |
| if effort is not None and effort not in entry.reasoning_efforts: | |
| raise CodeValidationError( | |
| "This effort is unavailable. Choose another effort." | |
| ) | |
| updates.update(model=model, reasoning_effort=effort) | |
| return _revision(self._session, **updates) | |
| def check_receipt(self, previous: CodeRun, text: str) -> None: | |
| if previous.session_id != self._session.id or previous.text != text: | |
| raise CodeConflictError( | |
| "This Send ID was already used for a different message." | |
| ) | |
| def check_can_send(self) -> None: | |
| if self.busy or self.pending: | |
| raise CodeConflictError("This session is busy. Your draft has been kept.") | |
| def prepare_admission( | |
| self, | |
| operation_id: str, | |
| text: str, | |
| model: str, | |
| reasoning_effort: str | None, | |
| mode: CodeMode, | |
| ) -> tuple[CodeSession, CodeRun, CodeItem]: | |
| self.check_can_send() | |
| run = CodeRun( | |
| id=operation_id, | |
| session_id=self._session.id, | |
| text=text, | |
| model=model, | |
| reasoning_effort=reasoning_effort, | |
| mode=mode, | |
| ) | |
| title = ( | |
| " ".join(text.split())[:80] | |
| if self._session.auto_title | |
| else self._session.title | |
| ) | |
| session = _revision(self._session, title=title, auto_title=False, error=None) | |
| item = CodeItem( | |
| id=operation_id, | |
| session_id=self._session.id, | |
| sequence=self._sequence + 1, | |
| run_id=operation_id, | |
| kind="user", | |
| text=text, | |
| complete=True, | |
| ) | |
| return session, run, item | |
| def active_run(self, run_id: str) -> CodeRun | None: | |
| return self._run if self._run and self._run.id == run_id and self.busy else None | |
| def request_stop(self) -> SessionProgress | None: | |
| run = self._run | |
| if run is None or run.stop_requested: | |
| return None | |
| return SessionProgress( | |
| self._session, | |
| run=run.model_copy(update={"stop_requested": True, "status": "stopping"}), | |
| ) | |
| def attach_thread( | |
| self, thread_id: str, permission_defaults: JsonObject | None = None | |
| ) -> SessionProgress: | |
| return SessionProgress( | |
| self._session.model_copy( | |
| update={ | |
| "native_thread_id": thread_id, | |
| "native_permission_defaults": self._session.native_permission_defaults | |
| if self._session.native_permission_defaults is not None | |
| else permission_defaults, | |
| } | |
| ) | |
| ) | |
| def prepare_submission(self) -> SessionProgress: | |
| assert self._run is not None | |
| if self._session.native_permission_defaults is None: | |
| raise CodeUnavailableError( | |
| "The harness did not return its permission settings. Your input was not sent." | |
| ) | |
| return SessionProgress( | |
| self._session.model_copy(update={"native_may_have_input": True}), | |
| run=self._run.model_copy(update={"submission_started": True}), | |
| ) | |
| def bind_turn(self, turn_id: str) -> SessionProgress: | |
| run = self._run | |
| assert run is not None | |
| if run.native_turn_id not in {None, turn_id}: | |
| raise CodeUnavailableError("Codex returned a different turn identity.") | |
| return SessionProgress( | |
| self._session, | |
| run=run.model_copy( | |
| update={ | |
| "native_turn_id": turn_id, | |
| "status": "stopping" if run.stop_requested else "running", | |
| } | |
| ), | |
| ) | |
| def accepts_event(self, event: HarnessEvent) -> bool: | |
| return self._session.status == "ready" and event.thread_id in { | |
| None, | |
| self._session.native_thread_id, | |
| } | |
| def matches_turn(self, event: HarnessEvent, *, known_turn: bool) -> bool: | |
| run = self._run | |
| return bool( | |
| run is not None | |
| and self.busy | |
| and run.submission_started | |
| and event.turn_id is not None | |
| and ( | |
| run.native_turn_id == event.turn_id | |
| or ( | |
| run.native_turn_id is None | |
| and event.kind == "turn_started" | |
| and not known_turn | |
| ) | |
| ) | |
| ) | |
| def context_usage(self, used_tokens: int | None) -> SessionProgress | None: | |
| if used_tokens is None or used_tokens == self._session.context_used_tokens: | |
| return None | |
| return SessionProgress( | |
| self._session.model_copy(update={"context_used_tokens": used_tokens}) | |
| ) | |
| def match_history( | |
| self, native: NativeThread, runs: Sequence[CodeRun] | |
| ) -> tuple[tuple[NativeTurn, CodeRun], ...]: | |
| saved = {run.id: run for run in runs} | |
| mapped: dict[str, CodeRun] = {} | |
| for turn in native.turns: | |
| identities = { | |
| item.client_id | |
| for item in turn.items | |
| if item.kind == "user" and item.client_id | |
| } | |
| candidates = [ | |
| run | |
| for run in saved.values() | |
| if run.native_turn_id == turn.id or run.id in identities | |
| ] | |
| if len(candidates) > 1 or any( | |
| identity not in saved for identity in identities | |
| ): | |
| raise CodeUnavailableError( | |
| "Codex history contains conflicting turn identities. Saved history was retained." | |
| ) | |
| if candidates: | |
| run = candidates[0] | |
| if ( | |
| not run.submission_started | |
| or run.native_turn_id not in {None, turn.id} | |
| or run.id in {value.id for value in mapped.values()} | |
| ): | |
| raise CodeUnavailableError( | |
| "Codex history could not be matched to its saved turns." | |
| ) | |
| mapped[turn.id] = run | |
| unmatched = [turn for turn in native.turns if turn.id not in mapped] | |
| pending = [ | |
| run | |
| for run in saved.values() | |
| if run.submission_started | |
| and run.native_turn_id is None | |
| and run.id not in {value.id for value in mapped.values()} | |
| ] | |
| if unmatched: | |
| if len(unmatched) != 1 or len(pending) != 1: | |
| raise CodeUnavailableError( | |
| "Codex history could not be matched to its saved turns. No input was resent." | |
| ) | |
| mapped[unmatched[0].id] = pending[0] | |
| # Recovery fills content and diagnostics, preserving outcomes already settled | |
| # by restart or connection loss. | |
| return tuple( | |
| ( | |
| turn, | |
| mapped[turn.id].model_copy( | |
| update={ | |
| "native_turn_id": turn.id, | |
| "error": mapped[turn.id].error or turn.error, | |
| "error_details": mapped[turn.id].error_details | |
| or turn.error_details, | |
| } | |
| ), | |
| ) | |
| for turn in native.turns | |
| ) | |
| def native_item(self, update: ItemUpdate) -> CodeItem | None: | |
| return next( | |
| ( | |
| item | |
| for item in self._items.values() | |
| if item.native_turn_id == update.turn_id | |
| and item.native_item_id == update.item_id | |
| ), | |
| None, | |
| ) | |
| def stage_item( | |
| self, update: ItemUpdate, run: CodeRun, *, historical: bool = False | |
| ) -> tuple[CodeItem, bool]: | |
| existing = self.native_item(update) | |
| if existing is None and update.kind == "user": | |
| if update.client_id is not None and update.client_id != run.id: | |
| raise CodeUnavailableError( | |
| "Codex returned a different message identity." | |
| ) | |
| existing = self._items.get(run.id) | |
| if existing is not None and existing.run_id != run.id: | |
| raise CodeUnavailableError( | |
| "Codex returned output belonging to another turn." | |
| ) | |
| if existing is None: | |
| self._sequence += 1 | |
| preserve = bool(historical and existing and existing.complete) | |
| raw = _merge_source(existing.raw if existing else {}, update.raw, preserve) | |
| text, detail = update.text, update.detail | |
| if historical and existing: | |
| text = (existing.text or text) if preserve else (text or existing.text) | |
| detail = ( | |
| (existing.detail or detail) if preserve else (detail or existing.detail) | |
| ) | |
| item = CodeItem( | |
| id=existing.id if existing else str(uuid.uuid4()), | |
| session_id=self._session.id, | |
| sequence=existing.sequence if existing else self._sequence, | |
| run_id=run.id, | |
| native_turn_id=update.turn_id, | |
| native_item_id=update.item_id, | |
| kind=update.kind, | |
| title=update.title or (existing.title if existing else ""), | |
| text=text, | |
| detail=detail, | |
| raw=raw, | |
| complete=update.complete or bool(existing and existing.complete), | |
| ) | |
| if item == existing: | |
| return existing, False | |
| self._items[item.id] = item | |
| self._dirty.add(item.id) | |
| self._dirty_characters += abs( | |
| len(item.text) - (len(existing.text) if existing else 0) | |
| ) + abs(len(item.detail) - (len(existing.detail) if existing else 0)) | |
| return item, True | |
| def stage_review( | |
| self, update: ItemUpdate, generation: str | |
| ) -> tuple[CodeItem | None, bool]: | |
| if self._run is None: | |
| return None, False | |
| existing = self.native_item(update) | |
| if existing is not None and existing.complete and not update.complete: | |
| return None, False | |
| target = self._runs[existing.run_id] if existing else self._run | |
| item, changed = self.stage_item(update, target) | |
| previous = self._review_generations.get(item.id) | |
| if item.complete: | |
| self._review_generations.pop(item.id, None) | |
| else: | |
| self._review_generations[item.id] = generation | |
| if previous != self._review_generations.get(item.id): | |
| # The saved row is reannounced when its connection liveness changes. | |
| self._dirty.add(item.id) | |
| return item, changed | |
| def has_prompt(self, request: PromptRequest, generation: str) -> bool: | |
| return any( | |
| prompt.generation == generation and prompt.request_id == request.request_id | |
| for prompt in self._prompts.values() | |
| ) | |
| def prepare_prompt( | |
| self, request: PromptRequest, generation: str | |
| ) -> SessionProgress: | |
| if self._run is None: | |
| raise CodeUnavailableError("Codex returned a prompt without a saved turn.") | |
| prompt = CodePrompt( | |
| id=str(uuid.uuid4()), | |
| session_id=self._session.id, | |
| generation=generation, | |
| request_id=request.request_id, | |
| native_turn_id=request.turn_id, | |
| native_item_id=request.item_id, | |
| kind=request.kind, | |
| form=request.form, | |
| raw=request.raw, | |
| ) | |
| item = CodeItem( | |
| id=prompt.id, | |
| session_id=self._session.id, | |
| run_id=self._run.id, | |
| sequence=self._sequence + 1, | |
| kind="prompt", | |
| complete=True, | |
| ) | |
| return SessionProgress(self._session, items=(item,), prompts=(prompt,)) | |
| def answerable_prompt( | |
| self, prompt_id: str, response_id: str, generation: str | None | |
| ) -> CodePrompt: | |
| prompt = self._prompts.get(prompt_id) | |
| if prompt is None: | |
| raise CodeNotFoundError("This prompt no longer exists.") | |
| if prompt.response_id == response_id: | |
| return prompt | |
| if prompt.status != "pending" or prompt.generation != generation: | |
| raise CodeConflictError( | |
| "This prompt was already answered or is no longer active." | |
| ) | |
| return prompt | |
| def pending_answer( | |
| self, prompt_id: str, generation: str | None | |
| ) -> CodePrompt | None: | |
| current = self._prompts.get(prompt_id) | |
| return ( | |
| current | |
| if current is not None | |
| and current.status == "answering" | |
| and current.generation == generation | |
| else None | |
| ) | |
| def resolve_answer( | |
| self, prompt_id: str, generation: str | None | |
| ) -> CodePrompt | None: | |
| current = self.pending_answer(prompt_id, generation) | |
| return current.model_copy(update={"status": "resolved"}) if current else None | |
| def expire_answer(self, prompt_id: str) -> CodePrompt | None: | |
| current = self._prompts.get(prompt_id) | |
| return ( | |
| current.model_copy(update={"status": "expired"}) | |
| if current and current.status == "answering" | |
| else None | |
| ) | |
| def resolve_request( | |
| self, request_id: str | int | None, generation: str | |
| ) -> tuple[CodePrompt, ...]: | |
| return tuple( | |
| prompt.model_copy(update={"status": "resolved"}) | |
| for prompt in self._prompts.values() | |
| if prompt.generation == generation | |
| and prompt.request_id == request_id | |
| and prompt.status in {"pending", "answering"} | |
| ) | |
| def expire_prompts(self) -> tuple[CodePrompt, ...]: | |
| return tuple( | |
| prompt.model_copy(update={"status": "expired"}) | |
| for prompt in self._prompts.values() | |
| if prompt.status in {"pending", "answering"} | |
| ) | |
| def prepare_notice(self, event: HarnessEvent) -> CodeItem: | |
| assert self._run is not None | |
| message = event.message or "Codex reported an error." | |
| if event.kind == "error" and event.will_retry: | |
| message = f"Retrying… {message}" | |
| return CodeItem( | |
| id=str(uuid.uuid4()), | |
| session_id=self._session.id, | |
| sequence=self._sequence + 1, | |
| run_id=self._run.id, | |
| kind="notice", | |
| title="Notice", | |
| text=message, | |
| complete=True, | |
| raw=event.raw, | |
| ) | |
| def prepare_finish( | |
| self, | |
| status: RunStatus, | |
| message: str | None = None, | |
| error_details: JsonObject | None = None, | |
| ) -> SessionProgress | None: | |
| if self._run is None or not self.busy: | |
| return None | |
| run = self._run.model_copy( | |
| update={ | |
| "status": status, | |
| "error": message, | |
| "error_details": error_details or {}, | |
| "finished_at": now_ms(), | |
| } | |
| ) | |
| prompts = tuple( | |
| prompt.model_copy(update={"status": "expired"}) | |
| for prompt in self._prompts.values() | |
| if prompt.status in {"pending", "answering"} | |
| and prompt.native_turn_id is not None | |
| and prompt.native_turn_id == run.native_turn_id | |
| ) | |
| return SessionProgress( | |
| _revision(self._session, error=None), | |
| run=run, | |
| items=self.pending_items, | |
| prompts=prompts, | |
| ) | |
| def prepare_delete(self) -> SessionProgress: | |
| if self.busy or self.pending: | |
| raise CodeConflictError( | |
| "Stop the session and finish its prompts before deleting it." | |
| ) | |
| return SessionProgress(_revision(self._session, status="deleting", error=None)) | |
| def deletion_failed( | |
| self, status: Literal["ready", "delete_uncertain"], message: str | |
| ) -> SessionProgress: | |
| return SessionProgress(_revision(self._session, status=status, error=message)) | |
| def _merge_source( | |
| previous: JsonObject, current: JsonObject, preserve: bool | |
| ) -> JsonObject: | |
| merged = dict(previous) | |
| for key, value in current.items(): | |
| existing = merged.get(key) | |
| if isinstance(existing, dict) and isinstance(value, dict): | |
| merged[key] = _merge_source(existing, value, preserve) | |
| elif not preserve or existing in (None, "", [], {}): | |
| merged[key] = value | |
| return merged | |
| def _revision(session: CodeSession, **updates: object) -> CodeSession: | |
| return session.model_copy( | |
| update={"revision": session.revision + 1, "updated_at": now_ms(), **updates} | |
| ) | |