codai-sdk 0.3.0__tar.gz → 0.4.0__tar.gz

{codai_sdk-0.3.0 → codai_sdk-0.4.0}/CHANGELOG.md

@@ -6,6 +6,23 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-09-27
+
+### Added
+
+- `client.resolve` — codai Resolve (pay per verified fix, `https://resolve.codai.ro`,
+  override with `resolve_base_url=`): `submit`, `get`, `accept`, `attestation`,
+  `health`, `wait_for`. `ResolveError` / `ResolveInsufficientFundsError` (402 carries
+  `topup_url`, `balance`, `required`). `RESOLVE_OPERATION_METHODS` maps every
+  `resolve.yaml` operationId; `_resolve_types.py` is generated from it.
+
+## [0.3.1] - 2026-09-26
+
+### Changed
+
+- Regenerated `_types.py`: project prebuild pool fields, environment `prebuild`
+  and `prebuild_claimed` on create (CE-0072).
+
 ## [0.3.0] - 2026-09-25
 
 ### Added

{codai_sdk-0.3.0 → codai_sdk-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codai-sdk
-Version: 0.3.0
+Version: 0.4.0
 Summary: Official Python SDK for the codai AI gateway — chat, messages, responses, streaming, agents, sessions, hosts, tasks, account.
 Project-URL: Homepage, https://codai.ro
 Project-URL: Repository, https://github.com/codai-ro/codai-sdk-python
@@ -147,6 +147,33 @@ Typed request/response shapes live in `codai._types` (generated from the
 OpenAPI spec — `TypedDict`s such as `ChatCompletionRequest`, `Task`,
 `SessionEvent`, `CreateSessionShareResponse`).
 
+## codai Resolve (0.4.0)
+
+Pay per verified fix: submit a public GitHub issue, get a flat quote, accept it
+(held on your wallet), and pay only when the fix passes your tests. First 3 fixes
+are free. Lives on `https://resolve.codai.ro` (same key; `resolve_base_url=` to override).
+
+```python
+from codai import Codai, ResolveInsufficientFundsError
+
+client = Codai(api_key="codai_...")
+job = client.resolve.submit({
+    "repo_url": "https://github.com/owner/repo",
+    "issue_url": "https://github.com/owner/repo/issues/42",
+})
+if job["status"] == "quoted":
+    try:
+        client.resolve.accept(job["id"])
+    except ResolveInsufficientFundsError as e:
+        print("top up first:", e.topup_url)
+        raise
+done = client.resolve.wait_for(job["id"])
+print(done["status"], done.get("attestation_url"))
+```
+
+Failed attempts and infrastructure errors refund the hold in full. Types:
+`codai._resolve_types` (generated from `resolve.yaml`).
+
 ## Development
 
 ```bash

{codai_sdk-0.3.0 → codai_sdk-0.4.0}/README.md

@@ -123,6 +123,33 @@ Typed request/response shapes live in `codai._types` (generated from the
 OpenAPI spec — `TypedDict`s such as `ChatCompletionRequest`, `Task`,
 `SessionEvent`, `CreateSessionShareResponse`).
 
+## codai Resolve (0.4.0)
+
+Pay per verified fix: submit a public GitHub issue, get a flat quote, accept it
+(held on your wallet), and pay only when the fix passes your tests. First 3 fixes
+are free. Lives on `https://resolve.codai.ro` (same key; `resolve_base_url=` to override).
+
+```python
+from codai import Codai, ResolveInsufficientFundsError
+
+client = Codai(api_key="codai_...")
+job = client.resolve.submit({
+    "repo_url": "https://github.com/owner/repo",
+    "issue_url": "https://github.com/owner/repo/issues/42",
+})
+if job["status"] == "quoted":
+    try:
+        client.resolve.accept(job["id"])
+    except ResolveInsufficientFundsError as e:
+        print("top up first:", e.topup_url)
+        raise
+done = client.resolve.wait_for(job["id"])
+print(done["status"], done.get("attestation_url"))
+```
+
+Failed attempts and infrastructure errors refund the hold in full. Types:
+`codai._resolve_types` (generated from `resolve.yaml`).
+
 ## Development
 
 ```bash

{codai_sdk-0.3.0 → codai_sdk-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codai-sdk"
-version = "0.3.0"
+version = "0.4.0"
 description = "Official Python SDK for the codai AI gateway — chat, messages, responses, streaming, agents, sessions, hosts, tasks, account."
 readme = "README.md"
 license = "MIT"

{codai_sdk-0.3.0 → codai_sdk-0.4.0}/scripts/gen-types.py

@@ -1,13 +1,15 @@
 #!/usr/bin/env python3
-"""Generate ``src/codai/_types.py`` from ``apps/docs/openapi/en/gateway.yaml``.
+"""Generate ``src/codai/_types.py`` from ``apps/docs/openapi/en/gateway.yaml``
+(and ``src/codai/_resolve_types.py`` from ``resolve.yaml`` with ``--spec resolve``).
 
 TypedDicts for every ``components.schemas`` entry plus a ``<operationId>Body`` /
 ``<operationId>Response`` alias for each operation's JSON request / 2xx body.
 Deterministic: the same spec always produces byte-identical output, so a second
 run is a no-op (the parity CI step diffs the committed file against a fresh run).
 
-    .\\.venv\\Scripts\\python scripts/gen-types.py          # write
-    .\\.venv\\Scripts\\python scripts/gen-types.py --check  # exit 1 when stale
+    .\\.venv\\Scripts\\python scripts/gen-types.py                   # write
+    .\\.venv\\Scripts\\python scripts/gen-types.py --check           # exit 1 when stale
+    .\\.venv\\Scripts\\python scripts/gen-types.py --spec resolve    # Resolve API types
 
 Dev-only dependency: pyyaml (``pip install -e ".[dev]"``). The runtime SDK stays
 zero-dependency — this script is never imported by the package.
@@ -25,15 +27,24 @@ import yaml
 
 HERE = Path(__file__).resolve().parent
 PKG = HERE.parent
-SPEC = PKG.parents[1] / "apps" / "docs" / "openapi" / "en" / "gateway.yaml"
+OPENAPI = PKG.parents[1] / "apps" / "docs" / "openapi" / "en"
+SPEC = OPENAPI / "gateway.yaml"
 OUT = PKG / "src" / "codai" / "_types.py"
+RESOLVE_SPEC = OPENAPI / "resolve.yaml"
+RESOLVE_OUT = PKG / "src" / "codai" / "_resolve_types.py"
+
+# --spec name → (spec file, output file, API label, regenerate command)
+TARGETS: Dict[str, Tuple[Path, Path, str, str]] = {
+    "gateway": (SPEC, OUT, "gateway", "python scripts/gen-types.py"),
+    "resolve": (RESOLVE_SPEC, RESOLVE_OUT, "Resolve", "python scripts/gen-types.py --spec resolve"),
+}
 
 HTTP_METHODS = ("get", "post", "put", "patch", "delete")
 
-HEADER = '''"""Typed dictionaries for the codai gateway API.
+HEADER = '''"""Typed dictionaries for the codai {api} API.
 
-generated — do not edit. Source: apps/docs/openapi/en/gateway.yaml.
-Regenerate with ``python scripts/gen-types.py`` (see that script's docstring).
+generated — do not edit. Source: apps/docs/openapi/en/{source}.
+Regenerate with ``{regen}`` (see that script's docstring).
 
 Every ``components.schemas`` entry is a ``TypedDict`` (``total=False`` when the
 schema has optional fields; a ``_<Name>Required`` base carries the required
@@ -76,8 +87,15 @@ def union(parts: List[str]) -> str:
 
 
 class Generator:
-    def __init__(self, spec: Dict[str, Any]) -> None:
+    def __init__(
+        self,
+        spec: Dict[str, Any],
+        api: str = "gateway",
+        source: str = "gateway.yaml",
+        regen: str = "python scripts/gen-types.py",
+    ) -> None:
         self.spec = spec
+        self.header = HEADER.format(api=api, source=source, regen=regen)
         self.schemas: Dict[str, Any] = spec["components"]["schemas"]
         self.blocks: List[Tuple[str, str]] = []
         self.emitted: Dict[str, str] = {}
@@ -295,7 +313,7 @@ class Generator:
         for name in self.schemas:  # YAML order
             self.ensure_schema(name)
         self.emit_operations()
-        out = [HEADER]
+        out = [self.header]
         for _, code in self.blocks:
             out.append(code)
             out.append("\n\n")
@@ -307,18 +325,23 @@ class Generator:
 
 
 def main(argv: List[str]) -> int:
-    with SPEC.open("r", encoding="utf-8") as fh:
+    name = argv[argv.index("--spec") + 1] if "--spec" in argv else "gateway"
+    if name not in TARGETS:
+        print(f"unknown --spec {name!r}; one of {', '.join(TARGETS)}", file=sys.stderr)
+        return 2
+    spec_path, out, api, regen = TARGETS[name]
+    with spec_path.open("r", encoding="utf-8") as fh:
         spec = yaml.safe_load(fh)
-    text = Generator(spec).render()
+    text = Generator(spec, api=api, source=spec_path.name, regen=regen).render()
     if "--check" in argv:
-        current = OUT.read_text(encoding="utf-8") if OUT.exists() else ""
+        current = out.read_text(encoding="utf-8") if out.exists() else ""
         if current != text:
-            print(f"STALE: {OUT} differs from a fresh generation", file=sys.stderr)
+            print(f"STALE: {out} differs from a fresh generation", file=sys.stderr)
             return 1
-        print(f"OK: {OUT} is up to date")
+        print(f"OK: {out} is up to date")
         return 0
-    OUT.write_text(text, encoding="utf-8", newline="\n")
-    print(f"wrote {OUT} ({text.count(chr(10))} lines, {len(spec['components']['schemas'])} schemas)")
+    out.write_text(text, encoding="utf-8", newline="\n")
+    print(f"wrote {out} ({text.count(chr(10))} lines, {len(spec['components']['schemas'])} schemas)")
     return 0
 
 

{codai_sdk-0.3.0 → codai_sdk-0.4.0}/src/codai/__init__.py

@@ -32,8 +32,9 @@ from __future__ import annotations
 from typing import Any, Dict, Generator, List, Optional
 
 from ._http import CodaiError, HttpClient, RequestExtensions, SseFrame, extension_headers, frame_json, read_sse
-from ._operations import OPERATION_METHODS, STREAMING_OPERATIONS
+from ._operations import OPERATION_METHODS, RESOLVE_OPERATION_METHODS, STREAMING_OPERATIONS
 from .resources import (
+    RESOLVE_TERMINAL_STATUSES,
     Account,
     AgentRunResult,
     Agents,
@@ -55,6 +56,9 @@ from .resources import (
     PhoneModels,
     Projects,
     Receipts,
+    Resolve,
+    ResolveError,
+    ResolveInsufficientFundsError,
     Responses,
     Sessions,
     SystemOne,
@@ -75,12 +79,16 @@ __all__ = [
     "RequestExtensions",
     "SseFrame",
     "OPERATION_METHODS",
+    "RESOLVE_OPERATION_METHODS",
+    "RESOLVE_TERMINAL_STATUSES",
+    "ResolveError",
+    "ResolveInsufficientFundsError",
     "STREAMING_OPERATIONS",
     "extension_headers",
     "frame_json",
     "read_sse",
 ]
-__version__ = "0.3.0"
+__version__ = "0.4.0"
 
 
 class _CallableGroup:
@@ -113,6 +121,7 @@ class Codai:
         client: Optional[str] = None,
         defaults: Optional[RequestExtensions] = None,
         opener: Any = None,
+        resolve_base_url: str = "https://resolve.codai.ro",
     ) -> None:
         if not api_key:
             raise ValueError("Codai: api_key is required")
@@ -156,6 +165,16 @@ class Codai:
         self.phone_models = PhoneModels(http)
         self.triggers = Triggers(http)
         self.notifications = Notifications(http)
+        # codai Resolve lives on its own host; same key, no X-Codai-* defaults.
+        self.resolve = Resolve(
+            HttpClient(
+                api_key=api_key,
+                base_url=resolve_base_url,
+                timeout=timeout,
+                max_retries=max_retries,
+                opener=opener,
+            )
+        )
 
         self.chat: Any = _CallableGroup(Chat(http), self._legacy_chat)
         self.embeddings: Any = _CallableGroup(Embeddings(http), self._legacy_embeddings)

{codai_sdk-0.3.0 → codai_sdk-0.4.0}/src/codai/_operations.py

@@ -123,6 +123,8 @@ OPERATION_METHODS: Dict[str, str] = {
     "receiveTriggerHook": "triggers.fire_hook",
     "listNotifications": "notifications.list",
     "markNotificationsRead": "notifications.mark_read",
+    "deleteNotification": "notifications.delete",
+    "deleteNotifications": "notifications.delete_many",
     # Account
     "getAccount": "account.get",
     "patchAccount": "account.update",
@@ -133,3 +135,12 @@ OPERATION_METHODS: Dict[str, str] = {
 
 # Operations whose SDK method is a generator (SSE-only endpoints).
 STREAMING_OPERATIONS: FrozenSet[str] = frozenset({"streamAgentRun", "streamSession", "streamHost"})
+
+# codai Resolve (``apps/docs/openapi/en/resolve.yaml``) → ``client.resolve.*``.
+RESOLVE_OPERATION_METHODS: Dict[str, str] = {
+    "resolveHealth": "resolve.health",
+    "createResolveJob": "resolve.submit",
+    "getResolveJob": "resolve.get",
+    "acceptResolveJob": "resolve.accept",
+    "getResolveAttestation": "resolve.attestation",
+}

codai_sdk-0.4.0/src/codai/_resolve_types.py

@@ -0,0 +1,174 @@
+"""Typed dictionaries for the codai Resolve API.
+
+generated — do not edit. Source: apps/docs/openapi/en/resolve.yaml.
+Regenerate with ``python scripts/gen-types.py --spec resolve`` (see that script's docstring).
+
+Every ``components.schemas`` entry is a ``TypedDict`` (``total=False`` when the
+schema has optional fields; a ``_<Name>Required`` base carries the required
+keys of mixed schemas). Non-object schemas (enums, unions, arrays) are type
+aliases. ``<operationId>Body`` / ``<operationId>Response`` name each
+operation's JSON request body and first 2xx JSON response.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Literal, Optional, TypedDict, Union
+
+class ResolveHealth(TypedDict):
+    ok: bool
+    service: str
+
+
+class ResolveValidationDetails(TypedDict):
+    """Zod `flatten()` output returned when the intake body fails schema validation."""
+    formErrors: List[str]
+    fieldErrors: Dict[str, List[str]]
+
+
+class ResolveError(TypedDict):
+    """Flat error envelope used by every Resolve endpoint. Not the gateway `{ error: { code, message } }` shape."""
+    error: Union[str, ResolveValidationDetails]
+
+
+class _ResolveIntakeRequired(TypedDict):
+    repo_url: str
+
+
+class ResolveIntake(_ResolveIntakeRequired, total=False):
+    """Body of `POST /v1/resolve/jobs`. Provide `issue_url` or `issue_text` (at least one)."""
+    issue_url: str
+    issue_text: str
+    test_command: str
+
+
+# `free` (first 3 resolves per user), `t7` ($7), `t19` ($19), `t49` ($49). Prices are in USD micros on the wire.
+ResolveTier = Literal['free', 't7', 't19', 't49']
+
+
+# Lifecycle: `triage → quoted → accepted → running → resolved | failed`, plus `declined`
+ResolveJobStatus = Literal['triage', 'quoted', 'declined', 'accepted', 'running', 'resolved', 'failed', 'error']
+
+
+class ResolveQuote(TypedDict):
+    """`201` body — the job was quoted (`quoted`) or auto-accepted on the free tier (`accepted`)."""
+    id: str
+    status: Literal['quoted', 'accepted']
+    tier: ResolveTier
+    quote_micro_usd: int
+    triage_reason: str
+    free_tier_remaining: int
+
+
+class ResolveDeclined(TypedDict):
+    """`200` body — triage declined the issue. The job is persisted with `status: declined` and is never billed."""
+    id: str
+    status: str
+    decline_reason: str
+
+
+class ResolveAccepted(TypedDict):
+    """Accepted"""
+    id: str
+    status: str
+
+
+class ResolveInsufficientFunds(TypedDict):
+    """`402` body of `POST /v1/resolve/jobs/{id}/accept` when the wallet cannot hold the quote."""
+    error: str
+    balance: int
+    required: int
+    currency: str
+    topup_url: str
+
+
+class ResolveJob(TypedDict):
+    """Full job view returned by `GET /v1/resolve/jobs/{id}`. Nullable fields are `null` until the corresponding stag…"""
+    id: str
+    status: ResolveJobStatus
+    repo_url: str
+    tier: Optional[ResolveTier]
+    quote_micro_usd: Optional[int]
+    triage_reason: Optional[str]
+    decline_reason: Optional[str]
+    fail_reason: Optional[str]
+    cost_micro_usd: int
+    attestation_id: Optional[str]
+    attestation_url: Optional[str]
+    created_at: str
+    completed_at: Optional[str]
+
+
+class ResolveReproTest(TypedDict):
+    """Repro test written by the agent when you did not supply `test_command`."""
+    path: str
+    content: Optional[str]
+
+
+class ResolveAttestation(TypedDict):
+    """Public execution proof. Everything needed to reproduce the verification locally."""
+    id: str
+    kind: str
+    repo_url: str
+    base_commit: str
+    patch: str
+    repro_test: Optional[ResolveReproTest]
+    test_command: str
+    regression_command: Optional[str]
+    test_output_before: str
+    test_output_after: str
+    regression_output: Optional[str]
+    runner_image_digest: str
+    started_at: str
+    verified_at: str
+
+
+# GET /health — 200 response
+ResolveHealthResponse = ResolveHealth
+
+
+# POST /v1/resolve/jobs — request body
+CreateResolveJobBody = ResolveIntake
+
+
+# POST /v1/resolve/jobs — 200 response
+CreateResolveJobResponse = ResolveDeclined
+
+
+# POST /v1/resolve/jobs — 201 response
+CreateResolveJobResponse201 = ResolveQuote
+
+
+# GET /v1/resolve/jobs/{id} — 200 response
+GetResolveJobResponse = ResolveJob
+
+
+# POST /v1/resolve/jobs/{id}/accept — 200 response
+AcceptResolveJobResponse = ResolveAccepted
+
+
+# GET /v1/resolve/attestations/{id} — 200 response
+GetResolveAttestationResponse = ResolveAttestation
+
+
+__all__ = [
+    'AcceptResolveJobResponse',
+    'CreateResolveJobBody',
+    'CreateResolveJobResponse',
+    'CreateResolveJobResponse201',
+    'GetResolveAttestationResponse',
+    'GetResolveJobResponse',
+    'ResolveAccepted',
+    'ResolveAttestation',
+    'ResolveDeclined',
+    'ResolveError',
+    'ResolveHealth',
+    'ResolveHealthResponse',
+    'ResolveInsufficientFunds',
+    'ResolveIntake',
+    'ResolveJob',
+    'ResolveJobStatus',
+    'ResolveQuote',
+    'ResolveReproTest',
+    'ResolveTier',
+    'ResolveValidationDetails',
+]

{codai_sdk-0.3.0 → codai_sdk-0.4.0}/src/codai/_types.py

@@ -17,7 +17,7 @@ from typing import Any, Dict, List, Literal, Optional, TypedDict, Union
 class _ErrorErrorRequired(TypedDict):
     message: str
     type: Literal['invalid_request_error', 'subscription_required', 'rate_limit_error', 'upstream_error', 'server_error']
-    code: Literal['bad_request', 'invalid_api_key', 'subscription_inactive', 'forbidden', 'not_found', 'payload_too_large', 'rate_limit_exceeded', 'quota_exceeded', 'upstream_error', 'internal_error', 'not_a_member', 'lease_held', 'seq_conflict', 'host_offline', 'host_timeout', 'rules_refused', 'search_unavailable', 'task_not_confirmable', 'slug_taken', 'project_has_environments', 'already_has_env', 'not_enrollable', 'not_byo', 'invalid_transition', 'already_member', 'vm_per_dev_single_member', 'last_owner']
+    code: Literal['bad_request', 'invalid_api_key', 'subscription_inactive', 'forbidden', 'not_found', 'payload_too_large', 'rate_limit_exceeded', 'quota_exceeded', 'upstream_error', 'internal_error', 'not_a_member', 'lease_held', 'seq_conflict', 'host_offline', 'host_timeout', 'rules_refused', 'search_unavailable', 'task_not_confirmable', 'slug_taken', 'project_has_environments', 'already_has_env', 'not_enrollable', 'not_byo', 'invalid_transition', 'already_member', 'vm_per_dev_single_member', 'last_owner', 'insufficient_balance', 'key_scope_forbidden']
 
 
 class ErrorError(_ErrorErrorRequired, total=False):
@@ -1362,7 +1362,7 @@ ProjectIsolation = Literal['shared_vm', 'container', 'vm_per_dev']
 
 
 # `byo` (bring your own machine; the daemon enrols with a token) is open to every key. `openstack` / `hetzner` a…
-EnvironmentProvider = Literal['byo', 'openstack', 'hetzner', 'local']
+EnvironmentProvider = Literal['byo', 'openstack', 'hetzner', 'local', 'gce']
 
 
 # Lifecycle state. `byo` starts in `pending` and reaches `enrolling` when the daemon enrols; managed providers s…
@@ -1380,8 +1380,7 @@ PortVisibility = Literal['owner', 'org', 'authenticated', 'public']
 PortProtocol = Literal['http', 'https', 'tcp']
 
 
-class Project(TypedDict):
-    """The stored project row (camelCase, as persisted)."""
+class _ProjectRequired(TypedDict):
     id: str
     ownerUserId: str
     orgId: Optional[str]
@@ -1396,6 +1395,13 @@ class Project(TypedDict):
     updatedAt: str
 
 
+class Project(_ProjectRequired, total=False):
+    """The stored project row (camelCase, as persisted)."""
+    prebuildPoolSize: int
+    prebuildProvider: Literal['openstack', 'hetzner']
+    prebuildSize: str
+
+
 class _ProjectCreateBodyRequired(TypedDict):
     name: str
 
@@ -1417,6 +1423,9 @@ class ProjectPatchBody(TypedDict, total=False):
     default_branch: str
     devcontainer_path: Optional[str]
     isolation: ProjectIsolation
+    prebuild_pool_size: int
+    prebuild_provider: Literal['openstack', 'hetzner']
+    prebuild_size: Literal['small', 'medium', 'large']
 
 
 class _EnvironmentRequired(TypedDict):
@@ -1450,6 +1459,7 @@ class _EnvironmentRequired(TypedDict):
 class Environment(_EnvironmentRequired, total=False):
     """The stored environment row (camelCase, as persisted) plus snake_case `for_user_id` and, when known, the projec…"""
     isolation: ProjectIsolation
+    prebuild: bool
 
 
 class _EnvironmentCreateBodyRequired(TypedDict):
@@ -1485,6 +1495,19 @@ class AlreadyHasEnvError(TypedDict):
     environment_id: str
 
 
+class InsufficientBalanceErrorError(TypedDict):
+    message: str
+    type: Literal['invalid_request_error']
+    code: Literal['insufficient_balance']
+    required_micro_eur: int
+    balance_micro_eur: int
+
+
+class InsufficientBalanceError(TypedDict):
+    """The `Error` envelope plus the one-hour amount the wallet must hold and what it holds now."""
+    error: InsufficientBalanceErrorError
+
+
 # Environment transition
 EnvironmentTransition = TypedDict(
     'EnvironmentTransition',
@@ -2476,10 +2499,14 @@ class ListEnvironmentsResponse(TypedDict):
 CreateEnvironmentBody = EnvironmentCreateBody
 
 
-class CreateEnvironmentResponse(TypedDict):
+class _CreateEnvironmentResponseRequired(TypedDict):
     environment: Environment
 
 
+class CreateEnvironmentResponse(_CreateEnvironmentResponseRequired, total=False):
+    prebuild_claimed: bool
+
+
 # POST /v1/environments/enroll — request body
 EnrollEnvironmentBody = EnvironmentEnrollBody
 
@@ -2721,6 +2748,18 @@ class MarkNotificationsReadResponse(TypedDict):
     read: int
 
 
+class DeleteNotificationResponse(TypedDict):
+    deleted: int
+
+
+class DeleteNotificationsBody(TypedDict):
+    ids: List[int]
+
+
+class DeleteNotificationsResponse(TypedDict):
+    deleted: int
+
+
 # POST /v1/hooks/{id} — request body
 ReceiveTriggerHookBody = Dict[str, Any]
 
@@ -2858,6 +2897,9 @@ __all__ = [
     'CreateTriggerBody',
     'CreateTriggerResponse',
     'DeleteDeviceResponse',
+    'DeleteNotificationResponse',
+    'DeleteNotificationsBody',
+    'DeleteNotificationsResponse',
     'DeleteProjectResponse',
     'DeleteSessionResponse',
     'DeleteSessionShareResponse',
@@ -2926,6 +2968,8 @@ __all__ = [
     'HostExecResultBody',
     'HostOp',
     'HostPresence',
+    'InsufficientBalanceError',
+    'InsufficientBalanceErrorError',
     'IssueMyEnvironmentSshCertBody',
     'IssueMyEnvironmentSshCertResponse',
     'ListAgentRunStepsResponse',

{codai_sdk-0.3.0 → codai_sdk-0.4.0}/src/codai/resources/__init__.py

@@ -36,11 +36,16 @@ from .platform import (
     Tools,
 )
 from .responses import Responses, ResponsesResult, ResponsesStream, ResponsesStreamResult
+from .resolve import RESOLVE_TERMINAL_STATUSES, Resolve, ResolveError, ResolveInsufficientFundsError
 from .sessions import SessionControls, SessionEvents, SessionLease, Sessions, SessionShares
 from .triggers import Notifications, Triggers
 
 __all__ = [
     "Account",
+    "RESOLVE_TERMINAL_STATUSES",
+    "Resolve",
+    "ResolveError",
+    "ResolveInsufficientFundsError",
     "AgentRunResult",
     "AgentRuns",
     "Agents",

codai_sdk-0.4.0/src/codai/resources/resolve.py

@@ -0,0 +1,148 @@
+"""codai Resolve — execution-verified bug fixes, no fix no fee.
+
+Separate service (``https://resolve.codai.ro``, spec ``apps/docs/openapi/en/resolve.yaml``)
+with a flat ``{"error": ...}`` body, so it runs on its own ``HttpClient`` and maps
+failures to ``ResolveError`` / ``ResolveInsufficientFundsError``. Mirrors
+``packages/sdk/src/resources/resolve.ts``.
+"""
+
+from __future__ import annotations
+
+import re
+import time
+from typing import Any, Callable, Dict, Iterable, Optional, cast
+
+from .._http import CodaiError, HttpClient
+from .._resolve_types import (
+    ResolveAccepted,
+    ResolveAttestation,
+    ResolveHealth,
+    ResolveIntake,
+    ResolveJob,
+)
+from ._base import enc
+
+__all__ = [
+    "RESOLVE_TERMINAL_STATUSES",
+    "Resolve",
+    "ResolveError",
+    "ResolveInsufficientFundsError",
+]
+
+RESOLVE_TERMINAL_STATUSES = frozenset({"resolved", "failed", "declined", "error"})
+_ATTESTATION_PREFIX = re.compile(r"^.*/v1/resolve/attestations/")
+
+
+class ResolveError(CodaiError):
+    """Any non-2xx answer from the Resolve service. ``detail`` is the body's ``error``
+    field: a message, or Zod ``flatten()`` details on a 400."""
+
+    def __init__(self, message: str, status: int, body: Any, request_id: Optional[str] = None,
+                 retry_after: Optional[int] = None) -> None:
+        super().__init__(message, status, body, code=_code(body), request_id=request_id, retry_after=retry_after)
+        err = body.get("error") if isinstance(body, dict) else None
+        self.detail: Any = err if isinstance(err, (str, dict)) else None
+
+
+class ResolveInsufficientFundsError(ResolveError):
+    """``402`` on ``accept()`` — the wallet cannot hold the quote; the job stays ``quoted``.
+    Open ``topup_url`` (pay.codai.ro checkout for the shortfall), then retry ``accept()``."""
+
+    def __init__(self, message: str, body: Dict[str, Any], request_id: Optional[str] = None) -> None:
+        super().__init__(message, 402, body, request_id=request_id)
+        self.balance: int = int(body["balance"])
+        self.required: int = int(body["required"])
+        self.currency: str = str(body["currency"])
+        self.topup_url: str = str(body["topup_url"])
+
+
+def _code(body: Any) -> Optional[str]:
+    err = body.get("error") if isinstance(body, dict) else None
+    return err if isinstance(err, str) else None
+
+
+def _to_resolve_error(path: str, err: CodaiError) -> CodaiError:
+    if isinstance(err, ResolveError) or err.status == 0:
+        return err
+    body = err.body
+    if (
+        err.status == 402
+        and isinstance(body, dict)
+        and body.get("error") == "insufficient_funds"
+        and isinstance(body.get("topup_url"), str)
+    ):
+        return ResolveInsufficientFundsError(
+            f"codai-resolve {path} → 402: insufficient funds (balance {body.get('balance')}, "
+            f"required {body.get('required')} {body.get('currency')}); top up at {body['topup_url']}",
+            body,
+            request_id=err.request_id,
+        )
+    detail = _code(body) or "request failed"
+    return ResolveError(
+        f"codai-resolve {path} → {err.status}: {detail}", err.status, body,
+        request_id=err.request_id, retry_after=err.retry_after,
+    )
+
+
+class Resolve:
+    """``client.resolve`` — submit, accept, poll and verify Resolve jobs."""
+
+    def __init__(self, http: HttpClient) -> None:
+        self._http = http
+
+    def _call(self, path: str, **kwargs: Any) -> Any:
+        try:
+            return self._http.json(path, **kwargs)
+        except CodaiError as e:
+            raise _to_resolve_error(path, e) from e
+
+    def submit(self, body: ResolveIntake) -> Dict[str, Any]:
+        """``POST /v1/resolve/jobs`` — returns a quote (``status: quoted``), a free-tier
+        auto-accept (``accepted``) or a decline (``declined``). Never retried."""
+        if not body.get("issue_url") and not body.get("issue_text"):
+            raise TypeError("resolve.submit: one of issue_url or issue_text is required")
+        return cast(Dict[str, Any], self._call("/v1/resolve/jobs", method="POST", body=dict(body), no_retry=True))
+
+    def get(self, job_id: str) -> ResolveJob:
+        """``GET /v1/resolve/jobs/{id}`` — status, quote, reasons, cost, attestation pointer."""
+        return cast(ResolveJob, self._call(f"/v1/resolve/jobs/{enc(job_id)}"))
+
+    def accept(self, job_id: str) -> ResolveAccepted:
+        """``POST /v1/resolve/jobs/{id}/accept`` — holds the quote on the wallet and starts
+        the job. Raises ``ResolveInsufficientFundsError`` (402) or ``ResolveError`` 409."""
+        return cast(
+            ResolveAccepted,
+            self._call(f"/v1/resolve/jobs/{enc(job_id)}/accept", method="POST", raw_body=b"", no_retry=True),
+        )
+
+    def attestation(self, id_or_url: str) -> ResolveAttestation:
+        """``GET /v1/resolve/attestations/{id}`` — accepts the id or the job's ``attestation_url``."""
+        att_id = _ATTESTATION_PREFIX.sub("", id_or_url)
+        return cast(ResolveAttestation, self._call(f"/v1/resolve/attestations/{enc(att_id)}"))
+
+    def health(self) -> ResolveHealth:
+        """``GET /health`` — liveness of the Resolve service."""
+        return cast(ResolveHealth, self._call("/health"))
+
+    def wait_for(
+        self,
+        job_id: str,
+        interval: float = 5.0,
+        timeout: float = 1800.0,
+        until: Optional[Iterable[str]] = None,
+        on_poll: Optional[Callable[[ResolveJob], None]] = None,
+    ) -> ResolveJob:
+        """Poll ``get()`` until a terminal status (or one of ``until``). A ``quoted`` job
+        does not move until you ``accept()`` it. Raises ``ResolveError`` (status 0) on timeout."""
+        stop = frozenset(until) if until is not None else RESOLVE_TERMINAL_STATUSES
+        deadline = time.monotonic() + timeout
+        while True:
+            job = self.get(job_id)
+            if on_poll is not None:
+                on_poll(job)
+            if job["status"] in stop:
+                return job
+            left = deadline - time.monotonic()
+            if left <= 0:
+                raise ResolveError(f"codai-resolve job {job_id} still {job['status']} after {timeout}s", 0, job)
+            time.sleep(min(interval, left))

{codai_sdk-0.3.0 → codai_sdk-0.4.0}/src/codai/resources/triggers.py

@@ -105,3 +105,11 @@ class Notifications(Resource):
         return self._json(
             "/v1/notifications/read", ext=ext, method="POST", body={"ids": ids} if ids is not None else {}
         )
+
+    def delete(self, id: int, ext: Optional[RequestExtensions] = None) -> Dict[str, Any]:
+        """``DELETE /v1/notifications/{id}`` — ``{"deleted": 0}`` when the id is missing or not yours."""
+        return self._json(f"/v1/notifications/{enc(str(id))}", ext=ext, method="DELETE")
+
+    def delete_many(self, ids: List[int], ext: Optional[RequestExtensions] = None) -> Dict[str, Any]:
+        """``POST /v1/notifications/delete`` — 1..200 ids; ids of other users are skipped."""
+        return self._json("/v1/notifications/delete", ext=ext, method="POST", body={"ids": ids})

{codai_sdk-0.3.0 → codai_sdk-0.4.0}/tests/test_parity.py

@@ -13,7 +13,7 @@ from typing import Any, Dict, List
 import pytest
 import yaml
 
-from codai import OPERATION_METHODS, STREAMING_OPERATIONS, Codai
+from codai import OPERATION_METHODS, RESOLVE_OPERATION_METHODS, STREAMING_OPERATIONS, Codai
 
 PKG = Path(__file__).resolve().parents[1]
 SPEC = PKG.parents[1] / "apps" / "docs" / "openapi" / "en" / "gateway.yaml"
@@ -94,9 +94,10 @@ def test_mapping_mirrors_typescript_sdk_when_present():
 
     pairs = re.findall(r"^\s*(\w+):\s*'([\w.]+)',", ts.read_text(encoding="utf-8"), re.M)
     ts_map = {k: v for k, v in pairs}
-    assert set(ts_map) == set(OPERATION_METHODS)
+    py_map = {**OPERATION_METHODS, **RESOLVE_OPERATION_METHODS}
+    assert set(ts_map) == set(py_map)
     snake = lambda s: re.sub(r"(?<!^)(?<!\.)(?=[A-Z])", "_", s).lower()  # noqa: E731
-    assert {k: snake(v) for k, v in ts_map.items()} == OPERATION_METHODS
+    assert {k: snake(v) for k, v in ts_map.items()} == py_map
 
 
 def test_generated_types_are_up_to_date():

codai_sdk-0.4.0/tests/test_resolve.py

@@ -0,0 +1,95 @@
+"""``client.resolve`` against the stub, plus parity with resolve.yaml operationIds."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+import yaml
+
+from codai import (
+    RESOLVE_OPERATION_METHODS,
+    Codai,
+    ResolveError,
+    ResolveInsufficientFundsError,
+)
+
+SPEC = Path(__file__).resolve().parents[3] / "apps" / "docs" / "openapi" / "en" / "resolve.yaml"
+JOB = "11111111-2222-4333-8444-555555555555"
+
+
+@pytest.fixture
+def rclient(stub) -> Codai:
+    return Codai(api_key="codai_test", resolve_base_url=stub.url, max_retries=0, timeout=5)
+
+
+def test_every_resolve_operation_is_mapped_and_callable(rclient):
+    spec = yaml.safe_load(SPEC.read_text(encoding="utf-8"))
+    ids = {op["operationId"] for item in spec["paths"].values() for op in item.values() if isinstance(op, dict) and "operationId" in op}
+    assert set(RESOLVE_OPERATION_METHODS) == ids
+    for dotted in RESOLVE_OPERATION_METHODS.values():
+        node = rclient
+        for part in dotted.split("."):
+            node = getattr(node, part)
+        assert callable(node)
+
+
+def test_submit_posts_intake_with_bearer(rclient, stub):
+    stub.reply(201, {"id": JOB, "status": "quoted", "tier": "t7"})
+    r = rclient.resolve.submit({"repo_url": "https://github.com/o/r", "issue_url": "https://github.com/o/r/issues/1"})
+    assert r["status"] == "quoted"
+    assert stub.last.method == "POST" and stub.last.path == "/v1/resolve/jobs"
+    assert stub.last.headers["authorization"] == "Bearer codai_test"
+    assert stub.last.json["repo_url"] == "https://github.com/o/r"
+
+
+def test_submit_requires_issue(rclient):
+    with pytest.raises(TypeError):
+        rclient.resolve.submit({"repo_url": "https://github.com/o/r"})
+
+
+def test_accept_sends_empty_body(rclient, stub):
+    stub.reply(202, {"id": JOB, "status": "accepted"})
+    r = rclient.resolve.accept(JOB)
+    assert r["status"] == "accepted"
+    assert stub.last.method == "POST"
+    assert stub.last.path == f"/v1/resolve/jobs/{JOB}/accept"
+    assert stub.last.body == b""
+
+
+def test_accept_402_maps_to_insufficient_funds(rclient, stub):
+    body = {
+        "error": "insufficient_funds",
+        "balance": 0,
+        "required": 7_000_000,
+        "currency": "micro_eur",
+        "topup_url": "https://pay.codai.ro/checkout?topup=10",
+    }
+    stub.reply(402, body)
+    with pytest.raises(ResolveInsufficientFundsError) as ei:
+        rclient.resolve.accept(JOB)
+    assert ei.value.status == 402
+    assert ei.value.required == 7_000_000
+    assert ei.value.topup_url.endswith("topup=10")
+
+
+def test_409_maps_to_resolve_error(rclient, stub):
+    stub.reply(409, {"error": "job is not quoted"})
+    with pytest.raises(ResolveError) as ei:
+        rclient.resolve.accept(JOB)
+    assert ei.value.status == 409 and ei.value.detail == "job is not quoted"
+    assert not isinstance(ei.value, ResolveInsufficientFundsError)
+
+
+def test_attestation_accepts_url(rclient, stub):
+    stub.reply(200, {"id": "att-1"})
+    rclient.resolve.attestation("https://resolve.codai.ro/v1/resolve/attestations/att-1")
+    assert stub.last.path == "/v1/resolve/attestations/att-1"
+
+
+def test_wait_for_polls_until_terminal(rclient, stub):
+    stub.reply(200, {"id": JOB, "status": "running"})
+    stub.reply(200, {"id": JOB, "status": "resolved"})
+    seen = []
+    job = rclient.resolve.wait_for(JOB, interval=0.01, on_poll=lambda j: seen.append(j["status"]))
+    assert job["status"] == "resolved" and seen == ["running", "resolved"]

{codai_sdk-0.3.0 → codai_sdk-0.4.0}/tests/test_resources.py

@@ -4,8 +4,10 @@ from __future__ import annotations
 
 import json
 
+import pytest
+
 import codai
-from codai import Codai, ChatResult
+from codai import Codai, ChatResult, CodaiError
 
 
 def _chat_response(content="PONG", tool_calls=None):
@@ -22,7 +24,7 @@ def _chat_response(content="PONG", tool_calls=None):
 
 
 def test_version():
-    assert codai.__version__ == "0.3.0"
+    assert codai.__version__ == "0.4.0"
 
 
 def test_chat_completions_create(client, stub):
@@ -329,3 +331,125 @@ def test_projects_and_environments_groups(client, stub):
     stub.reply(200, {"deleted": True, "name": "API_KEY"})
     client.environments.secrets.remove("e1", "API_KEY")
     assert stub.last.method == "DELETE" and stub.last.path == "/v1/environments/e1/secrets/API_KEY"
+
+
+def test_projects_get_returns_full_reply(client, stub):
+    reply = {"project": {"id": "p/1", "name": "brivio"}, "environments": [{"id": "e1"}]}
+    stub.reply(200, reply)
+    assert client.projects.get("p/1") == reply
+    assert stub.last.method == "GET" and stub.last.path == "/v1/projects/p%2F1"
+    assert stub.last.json is None
+
+
+def test_environments_get_and_update(client, stub):
+    detail = {"environment": {"id": "e1"}, "role": "owner", "members": [], "ports": [], "events": []}
+    stub.reply(200, detail)
+    assert client.environments.get("e 1") == detail
+    assert stub.last.method == "GET" and stub.last.path == "/v1/environments/e%201"
+    stub.reply(200, {"environment": {"id": "e1", "idle_timeout_minutes": 30}})
+    out = client.environments.update("e1", {"name": "dev", "idle_timeout_minutes": 30})
+    assert out == {"id": "e1", "idle_timeout_minutes": 30}
+    assert stub.last.method == "PATCH" and stub.last.path == "/v1/environments/e1"
+    assert stub.last.json == {"name": "dev", "idle_timeout_minutes": 30}
+
+
+def test_environment_members_list_add_remove(client, stub):
+    stub.reply(200, {"members": [{"user_id": "u1", "role": "owner"}]})
+    assert client.environments.members.list("e1") == [{"user_id": "u1", "role": "owner"}]
+    assert stub.last.method == "GET" and stub.last.path == "/v1/environments/e1/members"
+    stub.reply(200, {})
+    assert client.environments.members.list("e1") == []
+    stub.reply(201, {"member": {"user_id": "u2", "role": "developer"}})
+    out = client.environments.members.add("e1", {"email": "a@b.c", "role": "developer"})
+    assert out == {"user_id": "u2", "role": "developer"}
+    assert stub.last.method == "POST" and stub.last.path == "/v1/environments/e1/members"
+    assert stub.last.json == {"email": "a@b.c", "role": "developer"}
+    stub.reply(200, {"removed": True, "user_id": "u/2"})
+    assert client.environments.members.remove("e1", "u/2") == {"removed": True, "user_id": "u/2"}
+    assert stub.last.method == "DELETE" and stub.last.path == "/v1/environments/e1/members/u%2F2"
+
+
+def test_environment_members_ssh_cert(client, stub):
+    cert = {
+        "certificate": "ssh-ed25519-cert-v01@openssh.com AAAA u-1",
+        "host": "203.0.113.7",
+        "principal": "u-0f1d2c3e",
+        "valid_before": "2026-09-27T00:00:00.000Z",
+    }
+    stub.reply(200, cert)
+    out = client.environments.members.ssh_cert("env/1", {"public_key": "ssh-ed25519 AAAA ana@laptop"})
+    assert out == cert
+    assert stub.last.method == "POST"
+    assert stub.last.path == "/v1/environments/env%2F1/members/me/ssh-cert"
+    assert stub.last.json == {"public_key": "ssh-ed25519 AAAA ana@laptop"}
+
+
+def test_environment_members_ssh_cert_is_not_retried(stub):
+    c = Codai(api_key="codai_test", base_url=stub.url, max_retries=2, timeout=5)
+    stub.reply(503, {"error": {"message": "busy"}})
+    with pytest.raises(CodaiError) as ei:
+        c.environments.members.ssh_cert("e1", {"public_key": "ssh-ed25519 AAAA"})
+    assert ei.value.status == 503
+    assert len(stub.requests) == 1
+
+
+def test_environments_ssh_ca(client, stub):
+    keys = {"public_keys": ["ssh-ed25519 AAAA ca-current", "ssh-ed25519 BBBB ca-next"]}
+    stub.reply(200, keys)
+    assert client.environments.ssh_ca("e 1") == keys
+    assert stub.last.method == "GET" and stub.last.path == "/v1/environments/e%201/ssh-ca"
+    assert stub.last.json is None
+
+
+def test_environment_tasks_list_create_get(client, stub):
+    listing = {"tasks": [{"id": "t1", "status": "queued"}]}
+    stub.reply(200, listing)
+    assert client.environments.tasks.list("e1") == listing
+    assert stub.last.method == "GET" and stub.last.path == "/v1/environments/e1/tasks"
+
+    queued = {"task_id": "t1", "session_id": "s1", "status": "queued"}
+    stub.reply(202, queued)
+    out = client.environments.tasks.create("env/1", {"prompt": "add a /health route", "branch": "feat/health-route"})
+    assert out == queued
+    assert stub.last.method == "POST" and stub.last.path == "/v1/environments/env%2F1/tasks"
+    assert stub.last.json == {"prompt": "add a /health route", "branch": "feat/health-route"}
+    stub.reply(202, queued)
+    client.environments.tasks.create("e1", {"prompt": "no branch"})
+    assert stub.last.json == {"prompt": "no branch"}
+
+    detail = {"task": {"id": "t/1", "status": "done"}}
+    stub.reply(200, detail)
+    assert client.environments.tasks.get("e 1", "t/1") == detail
+    assert stub.last.method == "GET" and stub.last.path == "/v1/environments/e%201/tasks/t%2F1"
+
+
+def test_environment_tasks_create_is_not_retried(stub):
+    c = Codai(api_key="codai_test", base_url=stub.url, max_retries=2, timeout=5)
+    stub.reply(503, {"error": {"message": "busy"}})
+    with pytest.raises(CodaiError):
+        c.environments.tasks.create("e1", {"prompt": "x"})
+    assert len(stub.requests) == 1
+
+
+def test_environment_ports_list_remove_and_secrets_list(client, stub):
+    stub.reply(200, {"ports": [{"port": 3000, "visibility": "org"}]})
+    assert client.environments.ports.list("e1") == [{"port": 3000, "visibility": "org"}]
+    assert stub.last.method == "GET" and stub.last.path == "/v1/environments/e1/ports"
+    stub.reply(200, {"deleted": True, "port": 3000})
+    assert client.environments.ports.remove("e1", 3000) == {"deleted": True, "port": 3000}
+    assert stub.last.method == "DELETE" and stub.last.path == "/v1/environments/e1/ports/3000"
+    stub.reply(200, {"secrets": [{"name": "API_KEY", "updated_at": "2026-09-26T00:00:00Z"}]})
+    assert client.environments.secrets.list("e1") == [{"name": "API_KEY", "updated_at": "2026-09-26T00:00:00Z"}]
+    assert stub.last.method == "GET" and stub.last.path == "/v1/environments/e1/secrets"
+    stub.reply(200, {"secrets": None})
+    assert client.environments.secrets.list("e1") == []
+
+
+def test_notifications_delete_and_delete_many(client, stub):
+    stub.reply(200, {"deleted": 1})
+    assert client.notifications.delete(7) == {"deleted": 1}
+    assert stub.last.method == "DELETE" and stub.last.path == "/v1/notifications/7"
+    stub.reply(200, {"deleted": 2})
+    assert client.notifications.delete_many([3, 4]) == {"deleted": 2}
+    assert stub.last.method == "POST" and stub.last.path == "/v1/notifications/delete"
+    assert stub.last.json == {"ids": [3, 4]}