mainsequence 9.0.2.dev32__py3-none-any.whl → 9.0.3.dev33__py3-none-any.whl

agent_scaffold/AGENTS.md

@@ -83,6 +83,9 @@ bundle. Platform skills are installed separately under
   `.agents/skills/mainsequence/platform_operations/orchestration_and_releases/SKILL.md`
 - RBAC, sharing, constants, secrets, and access verification:
   `.agents/skills/mainsequence/platform_operations/access_control_and_sharing/SKILL.md`
+- Direct recorded model calls, structured extraction, thinking/provider options,
+  inference history and idempotent replay:
+  `.agents/skills/mainsequence/mainsequence-inference/SKILL.md`
 - A2A session discovery, messages, files, and SDK response handling:
   `.agents/skills/mainsequence/a2a_sdk_execution/SKILL.md`
 - Turning a CodeRepository into a platform coding agent or selecting other

agent_scaffold/skills/mainsequence-inference/SKILL.md

@@ -0,0 +1,198 @@
+---
+name: mainsequence-inference
+description: Use the Main Sequence Python SDK for direct recorded model completions and structured extraction, with thinking levels, provider-native options, conversation history and safe replay. Use for model calls that do not need an Agent or A2A session.
+---
+
+# Main Sequence Recorded Inference
+
+Use `mainsequence.client.InferenceClient` to call the recorded inference endpoint.
+Main Sequence authenticates the caller, uses existing stored provider credentials,
+and records input/output. No Agent, AgentSession, Tau runtime or application-side
+provider key is required. This skill teaches the SDK client; the platform owns
+provider availability, permissions and execution behavior.
+
+## Establish the client and model
+
+Use the installed `mainsequence.client.inference` implementation and its matching
+[inference documentation](https://mainsequence-sdk.github.io/mainsequence-sdk/knowledge/infrastructure/inference/).
+If the installed SDK lacks `InferenceClient`, report the missing capability. Do
+not silently upgrade the SDK, restore retired `Agent.respond` calls, or replace
+recorded inference with direct provider HTTP calls.
+
+Reuse existing Main Sequence authentication and the current provider catalog.
+Select an exact available provider/model with configured credentials; examples
+below illustrate request shapes, not a guarantee that an account can use a model.
+There is no inference CLI command; use the Python client.
+
+For local CodeRepository code using human credentials, resolve the Environment
+from the current Git checkout through the existing SDK context:
+
+```python
+from mainsequence.client import InferenceClient
+from mainsequence.code_repository_context import get_code_repository_context
+
+context = get_code_repository_context()
+if context.organization_environment_uid is None:
+    raise RuntimeError("This checkout has no resolved Organization Environment")
+client = InferenceClient(
+    organization_environment_uid=context.organization_environment_uid,
+)
+```
+
+For an authenticated deployed runtime, use `InferenceClient()`; the server derives
+its exact Environment. A contradictory selector fails. Outside a CodeRepository,
+human callers provide an authorized Environment UID from their application
+context. Never invent an Environment, use another branch as a fallback, or add
+inference environment variables. Provider secrets remain in existing server-side
+credential storage and must not appear in messages or `provider_options`.
+
+## Construct a completion envelope
+
+Every call supplies complete ordered text messages: `system`, `user`, `assistant`.
+Earlier requests are never automatically prepended. An omitted `conversation_uid`
+creates a conversation; an existing UID groups another independent request with
+its own full context. Each new logical call needs its own idempotency key.
+
+```python
+def extract_weight(client, document, *, idempotency_key, conversation_uid=None):
+    return client.complete(
+        provider="openai",
+        model="gpt-5.4",  # Replace with the exact available catalog selection.
+        messages=[
+            {"role": "system", "content": "Extract the fund weight as a fraction."},
+            {"role": "user", "content": document},
+        ],
+        thinking_level="high",
+        provider_options={"store": False, "text": {"verbosity": "low"}},
+        response_schema={
+            "type": "object",
+            "properties": {"weight": {"type": "number"}},
+            "required": ["weight"],
+            "additionalProperties": False,
+        },
+        metadata={"operation": "fund-weight-extraction"},
+        conversation_uid=conversation_uid,
+        idempotency_key=idempotency_key,
+    )
+```
+
+`response_schema`, `thinking_level`, `provider_options`, `provider_storage`,
+`metadata` and `conversation_uid` are optional. Metadata is recorded content,
+not authorization or a credential selector. Keep sensitive payloads out of logs.
+The current contract accepts bounded text/JSON; it does not execute tools, stream,
+fetch document URLs, or accept file/image attachments. Extract document text first.
+
+Only consume `result.output["content"]` when `result.status == "completed"`,
+`result.content_available` is true, and `result.output` is present.
+A validated common `response_schema` returns parsed JSON there; ordinary text
+completions return a string. A replay can return a pending result without output.
+Preserve `conversation_uid` and `request_uid` from `InferenceResult` for inspection.
+
+## Thinking and native provider options
+
+`thinking_level` accepts the catalog vocabulary `off`, `minimal`, `low`, `medium`,
+`high`, `xhigh`, but the exact model and adapter must support the requested level.
+Unsupported mappings fail; do not silently lower the level to make a call work.
+Omitting the field preserves native thinking options, or the provider default
+when none are supplied. `off` is an explicit selection, not omission.
+
+Use `provider_options` for native JSON body fields the caller knows. Objects,
+arrays, numbers, false and null are preserved. Disjoint nested fields merge;
+colliding explicit common/native controls fail even when their values agree.
+Do not combine `thinking_level` with native thinking selection or
+`provider_storage.store_response` with native `store`. Omit the corresponding
+common convenience when choosing native configuration.
+
+| Family | Native `provider_options` example | Meaning |
+| --- | --- | --- |
+| OpenAI Responses | `{"reasoning": {"effort": "high"}, "store": false, "text": {"verbosity": "low"}}` | Native reasoning and storage; Chat Completions uses `reasoning_effort` instead. The catalog chooses the API. |
+| Anthropic Messages | `{"thinking": {"type": "adaptive"}, "output_config": {"effort": "high"}, "max_tokens": 4096}` | For an adaptive model; older models can use their native thinking budget. Do not send an invented OpenAI `store` flag. |
+| Ollama compatible API | `{"reasoning_effort": "high"}` | Select the existing Organization custom-provider identifier and a compatible model/API. Native Ollama `/api/chat` fields are not automatically translated. |
+| OpenRouter Chat | `{"reasoning": {"effort": "high"}, "provider": {"require_parameters": true, "zdr": true}}` | The nested `provider` object is upstream routing, distinct from the top-level catalog selector. ZDR routing is not proof of account-wide zero retention. |
+
+These are independent native-only examples: omit `thinking_level` when using
+them. Main Sequence forwards accepted native fields without inventing a normalized
+thinking level or claiming a provider honored an unknown option. Native fields
+cannot override the canonical model/input, credentials, endpoint, headers,
+streaming/background lifecycle, provider continuation, tool execution or alternate
+model selection. Common OpenRouter thinking/schema controls already add
+`provider.require_parameters`; do not also set that path in native options.
+
+## Provider storage versus Main Sequence history
+
+**Main Sequence keeps every admitted conversation exchange until explicitly
+deleted.** Provider storage controls never disable this history. Do not add an
+expiry setting, capture opt-in, `record_history=False`, or a new policy registry.
+
+- OpenAI: `provider_storage={"store_response": False}` compiles to `store: false`.
+  Choose this convenience or native `provider_options={"store": False}`.
+- Anthropic: `store_response=False` means the stateless Messages contract. It
+  does not promise that operational logs or caches do not exist.
+- Ollama and OpenRouter: the common storage convenience is not supported as a
+  universal per-request guarantee. Use supported native/account controls; do not
+  add or drop flags silently. Ollama is configured through existing custom
+  providers; `keep_alive` governs model residency, not conversation retention.
+- `provider_storage={"require_zero_data_retention": True}` currently rejects
+  before dispatch because verified account eligibility is unavailable. Neither
+  OpenAI `store: false` nor OpenRouter `provider.zdr` establishes that guarantee.
+
+## Handle outcomes and replay
+
+Create and persist the key with the application's logical request **before** its
+first submission. Keys contain 1–128 letters, digits, `.`, `_`, `:` or `-`. Do not
+put key generation inside a retry loop. Preserve the exact envelope for replay,
+including conversation creation/attachment, model, thinking, native options,
+metadata and schema. Reuse the same User, Environment and authenticated workload;
+idempotency is scoped to that context, not global across unrelated JobRuns.
+
+- `InferenceExecutionError` exposes `result` and `status_code`. Retain the
+  returned IDs and inspect `client.request(error.result.request_uid)`. Invalid
+  structured output, provider failure and unknown outcomes are not successes.
+- `InferenceTransportError` retains `idempotency_key`; the outcome may already
+  be recorded or executing. Inspect known request/history IDs, or explicitly
+  replay the identical envelope and key. Never substitute a new key after an
+  ambiguous result. Lower-level HTTP failures also do not justify a fresh key.
+- `admitted`/`dispatching` means pending; `completed` means persisted success;
+  `failed`/`unknown` requires inspection. Replaying unknown work does not execute
+  again. A changed envelope with the same key conflicts (409); deleted content
+  yields a recorded 410. Do not hide these cases behind an automatic retry loop.
+
+The client does not automatically retry network failures. It permits one refresh
+following an explicit authentication 401, preserving body and key. A longer
+client `timeout` does not extend the server's execution deadline. Neither a
+transport timeout nor `unknown` proves the provider stopped processing.
+Missing usage remains unknown; inspect `usage["complete"]` where present instead
+of treating absent token counts as a free call. Native-only structured output
+is not automatically validated by the common `response_schema` validator.
+
+## Read history and delete only when requested
+
+```python
+conversations = client.conversations(limit=25, offset=0)
+conversation = client.conversation(result.conversation_uid)
+request = client.request(result.request_uid)
+history = client.history(result.conversation_uid, limit=25, offset=0)
+insights = client.insights(result.conversation_uid)
+```
+
+Lists/history return `count`, `next`, `previous`, `results`; request retrieval
+returns `InferenceResult`. History records each complete submitted context and its
+output in admission order, not model-managed memory. Insights summarize outcomes,
+submitted messages and known tokens with unknown-usage counts. Read methods never
+invoke the model. The owner and authorized same-Organization administrators can
+inspect content within the admitted Environment; only the owner can append.
+
+For an explicit content-deletion request, use
+`client.delete_content(conversation_uid)`. It removes protected inputs, outputs,
+schemas and options, while keeping request identity and non-content outcome/usage
+records. Replay never reconstructs deleted content or runs the provider again,
+even if a response arrives after deletion. Do not schedule automatic deletion.
+
+## Verify an integration
+
+Mock the provider-facing boundary or SDK transport for local tests. Check the
+chosen thinking/native envelope, parsed structured result, stable retry identity,
+pending/error handling and history retrieval. Make a live provider call only
+when the task authorizes it and the existing account is ready; a successful call
+does not verify the provider's retention practices. Report mocked versus live
+verification clearly.

agent_scaffold/skills/sdk_code_repository_execution/SKILL.md

@@ -60,6 +60,9 @@ Do not let this skill become a domain manual.
   `.agents/skills/mainsequence/platform_operations/orchestration_and_releases/SKILL.md`
 - RBAC and sharing:
   `.agents/skills/mainsequence/platform_operations/access_control_and_sharing/SKILL.md`
+- direct recorded inference, structured extraction, thinking/provider controls,
+  conversation history and safe replay:
+  `.agents/skills/mainsequence/mainsequence-inference/SKILL.md`
 - TAU-based Harness Agent repository integration, local development, project
   customization, and runtime A2A adaptation: use the version-matched skills in
   `.agents/skills/ms_tau_sdk/` after the platform-owned skill defines the

mainsequence/cli/api.py

@@ -810,7 +810,7 @@ def get_logged_user_details() -> dict[str, Any]:
                 organization.pop("id", None)
             return user
         if hasattr(user, "model_dump"):
-            payload = user.model_dump()
+            payload = user.model_dump(mode="json")
             payload.pop("id", None)
             organization = payload.get("organization")
             if isinstance(organization, dict):

mainsequence/cli/cli.py

@@ -285,7 +285,7 @@ def _to_jsonable(value):
         return [_to_jsonable(item) for item in value]
     if isinstance(value, datetime.datetime | datetime.date | datetime.time):
         return value.isoformat()
-    if isinstance(value, pathlib.Path):
+    if isinstance(value, pathlib.Path | uuid.UUID):
         return str(value)
     if isinstance(value, PyEnum):
         return value.value

mainsequence/client/__init__.py

@@ -1,6 +1,18 @@
 from mainsequence.logconf import logger as logger
 
 from .github_issues import *  # noqa: F403
+from .inference import (
+    InferenceClient as InferenceClient,
+)
+from .inference import (
+    InferenceExecutionError as InferenceExecutionError,
+)
+from .inference import (
+    InferenceResult as InferenceResult,
+)
+from .inference import (
+    InferenceTransportError as InferenceTransportError,
+)
 from .models_foundry import *  # noqa: F403
 from .models_helpers import *  # noqa: F403
 from .models_user import *  # noqa: F403

mainsequence/client/inference.py

@@ -0,0 +1,184 @@
+"""Recorded model calls through Main Sequence's authenticated API."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any
+from uuid import UUID
+
+import requests
+from pydantic import BaseModel, ConfigDict, Field, ValidationError
+
+from . import utils
+from .exceptions import raise_for_response
+
+
+class InferenceResult(BaseModel):
+    model_config = ConfigDict(extra="allow")
+    conversation_uid: str
+    request_uid: str
+    sequence: int
+    provider: str
+    model: str
+    status: str
+    error_code: str
+    content_available: bool
+    usage: dict[str, Any] = Field(default_factory=dict)
+    input: dict[str, Any] | None = None
+    output: dict[str, Any] | None = None
+    effective_controls: dict[str, Any] = Field(default_factory=dict)
+    provider_error: dict[str, Any] | None = None
+
+
+class InferenceExecutionError(RuntimeError):
+    """A recorded failure; inspect ``result.request_uid`` without re-executing."""
+
+    def __init__(self, result: InferenceResult, status_code: int):
+        self.result = result
+        self.status_code = status_code
+        super().__init__(result.error_code or result.status)
+
+
+class InferenceTransportError(RuntimeError):
+    """Outcome is uncertain. Replay the same body and idempotency key only."""
+
+    def __init__(self, idempotency_key: str | None):
+        self.idempotency_key = idempotency_key
+        super().__init__(
+            "The request outcome is unknown. Inspect history or replay the identical request with the same idempotency key."
+        )
+
+
+class InferenceClient:
+    """Full caller-supplied context, with durable history and no Agent dependency.
+
+    Runtime credentials derive their Environment on the server. Human callers
+    provide ``organization_environment_uid`` explicitly. Provider secrets never
+    pass through this client. Optional provider options retain native JSON values.
+    """
+
+    def __init__(self, *, organization_environment_uid: str | UUID | None = None):
+        self.organization_environment_uid = (
+            str(UUID(str(organization_environment_uid)))
+            if organization_environment_uid is not None
+            else None
+        )
+
+    def _request(self, method, path, *, body=None, key=None, params=None, timeout=100):
+        query = dict(params or {})
+        if self.organization_environment_uid is not None:
+            query["organization_environment_uid"] = self.organization_environment_uid
+        url = f"{utils.API_ENDPOINT.rstrip('/')}/{path}"
+        # The shared make_request loop retries network failures. Inference uses
+        # the same auth loader with a dedicated zero-retry transport instead.
+        with utils.build_session(loaders=utils.loaders, retries=0) as session:
+            headers = dict(utils.loaders.refresh_headers(force=False, session=session))
+            if key is not None:
+                headers["Idempotency-Key"] = key
+            try:
+                response = session.request(
+                    method,
+                    url,
+                    headers=headers,
+                    params=query,
+                    json=body,
+                    timeout=timeout,
+                    allow_redirects=False,
+                )
+                if response.status_code == 401:
+                    headers.update(utils.loaders.refresh_headers(force=True, session=session))
+                    response = session.request(
+                        method,
+                        url,
+                        headers=headers,
+                        params=query,
+                        json=body,
+                        timeout=timeout,
+                        allow_redirects=False,
+                    )
+            except requests.RequestException as exc:
+                raise InferenceTransportError(key) from exc
+        if method == "POST":
+            try:
+                payload = response.json()
+            except ValueError as exc:
+                raise_for_response(response)
+                raise InferenceTransportError(key) from exc
+            if isinstance(payload, dict) and "request_uid" in payload:
+                try:
+                    result = InferenceResult.model_validate(payload)
+                except ValidationError as exc:
+                    raise InferenceTransportError(key) from exc
+                if response.status_code >= 400:
+                    raise InferenceExecutionError(result, response.status_code)
+                return result
+            raise_for_response(response)
+            raise InferenceTransportError(key)
+        raise_for_response(response)
+        return response.json()
+
+    def complete(
+        self,
+        *,
+        provider: str,
+        model: str,
+        messages: list[dict[str, str]],
+        idempotency_key: str,
+        conversation_uid: str | UUID | None = None,
+        thinking_level: str | None = None,
+        provider_options: dict[str, Any] | None = None,
+        provider_storage: dict[str, Any] | None = None,
+        response_schema: dict[str, Any] | None = None,
+        metadata: dict[str, Any] | None = None,
+        timeout: float = 100,
+    ) -> InferenceResult:
+        """Execute once or replay an existing identity; never generate a retry key."""
+        import re
+
+        if not isinstance(idempotency_key, str) or not re.fullmatch(
+            r"[A-Za-z0-9._:-]{1,128}", idempotency_key
+        ):
+            raise ValueError(
+                "idempotency_key must contain 1–128 letters, digits, dots, underscores, colons or hyphens."
+            )
+        body = {"provider": provider, "model": model, "messages": deepcopy(messages)}
+        if conversation_uid is not None:
+            body["conversation_uid"] = str(UUID(str(conversation_uid)))
+        for name, value in (
+            ("thinking_level", thinking_level),
+            ("provider_options", provider_options),
+            ("provider_storage", provider_storage),
+            ("response_schema", response_schema),
+            ("metadata", metadata),
+        ):
+            if value is not None:
+                body[name] = deepcopy(value)
+        return self._request(
+            "POST", "inference/completions/", body=body, key=idempotency_key, timeout=timeout
+        )
+
+    def conversations(self, *, limit: int = 25, offset: int = 0) -> dict[str, Any]:
+        return self._request(
+            "GET", "inference/conversations/", params={"limit": limit, "offset": offset}
+        )
+
+    def conversation(self, uid: str | UUID) -> dict[str, Any]:
+        return self._request("GET", f"inference/conversations/{UUID(str(uid))}/")
+
+    def history(self, uid: str | UUID, *, limit: int = 25, offset: int = 0) -> dict[str, Any]:
+        return self._request(
+            "GET",
+            f"inference/conversations/{UUID(str(uid))}/history/",
+            params={"limit": limit, "offset": offset},
+        )
+
+    def request(self, uid: str | UUID) -> InferenceResult:
+        return InferenceResult.model_validate(
+            self._request("GET", f"inference/requests/{UUID(str(uid))}/")
+        )
+
+    def insights(self, uid: str | UUID) -> dict[str, Any]:
+        return self._request("GET", f"inference/conversations/{UUID(str(uid))}/insights/")
+
+    def delete_content(self, uid: str | UUID) -> dict[str, Any]:
+        return self._request("DELETE", f"inference/conversations/{UUID(str(uid))}/content/")

{mainsequence-9.0.2.dev32.dist-info → mainsequence-9.0.3.dev33.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 9.0.2.dev32
+Version: 9.0.3.dev33
 Summary: Main Sequence SDK
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

{mainsequence-9.0.2.dev32.dist-info → mainsequence-9.0.3.dev33.dist-info}/RECORD

@@ -1,12 +1,13 @@
-agent_scaffold/AGENTS.md,sha256=yLTuL2VuT47JoBa7w7eekcWhenWciySPQmO9mAIBALE,6178
+agent_scaffold/AGENTS.md,sha256=fRFmLrFRhFI6T54YTjPLMeGXXtvwucC3yzDweQ_uycE,6366
 agent_scaffold/skills/a2a_sdk_execution/SKILL.md,sha256=NKtcXibE8TxZzKzz1KzJ2cVZ_EeuJJkb660U6wLvZ3s,11809
 agent_scaffold/skills/application_surfaces/api_surfaces/SKILL.md,sha256=zETXg2fFCujdorOqI2yjhH4Zv1nS16il8uuohF3jz60,13883
+agent_scaffold/skills/mainsequence-inference/SKILL.md,sha256=IrVnpuzFMZ3_x5oSH4OiPZsZ5jFf_aKdxEynrQhnRZE,11627
 agent_scaffold/skills/maintenance/bug_auditor/SKILL.md,sha256=pV8g6FbSgZu1ZsrCaWAbrf6MpetxMqoZKO1rBbtZMgs,8591
 agent_scaffold/skills/maintenance/code_repository_maintenance/SKILL.md,sha256=PczPIOM1YPyXlgd7i5OyN5DkYVwGHrDowsyoxzAqsi8,13396
 agent_scaffold/skills/maintenance/metatables_transition/SKILL.md,sha256=PisgpytcksJnfZMS6aiPCmahsT3fm8DIwk_cefXA2qU,3759
 agent_scaffold/skills/platform_operations/access_control_and_sharing/SKILL.md,sha256=o1rIlYAC7ejV7gKKf-BaglIZY1YkDO5Y27F6e2eK_94,8571
 agent_scaffold/skills/platform_operations/orchestration_and_releases/SKILL.md,sha256=F2I_pwzhbVW-32pBHQZfLnX6BC76iiILHZU1ewy2VYo,15245
-agent_scaffold/skills/sdk_code_repository_execution/SKILL.md,sha256=j9kiatMcQ6y2QQidwBp13Y2aSYsQwoK7_qWylC4Nb7g,10005
+agent_scaffold/skills/sdk_code_repository_execution/SKILL.md,sha256=XjZiRQ-4XCSgcanXvQcSd0BiDvBA9S92-8jpVx79hUs,10189
 mainsequence/__init__.py,sha256=70CbIo7ZG1mzi5uwkqDtVESunBE0RanHjeFg4ptfsA0,385
 mainsequence/__main__.py,sha256=KuAP69uduS2ImrPIgNMzbGBRepZzjqvUONu5vFh4v4A,176
 mainsequence/_request_identity.py,sha256=jiroPFVDM8vphEf9VXuggQJKUOGohfk7-pDwJSOILEw,1211
@@ -19,9 +20,9 @@ mainsequence/repository_identity_security.py,sha256=Cdywndhiy1zJFUPh-FfM90RjZ3Hg
 mainsequence/runtime_flags.py,sha256=1eTM7VRRhnuZ_GXcmFhqAmdEKwyQYMyZcPsio88vJRQ,378
 mainsequence/scaffold_skills.py,sha256=k0V6eKC5AwbHr9wB9UGMJNF-8eJ0_1izF4-BU01KHrg,10606
 mainsequence/cli/__init__.py,sha256=sMWTnomCaISjnureLuXFRqOzkH2Y77uYEivsd-M6_8Y,28
-mainsequence/cli/api.py,sha256=r9D0lSaw2Ah-39i04w9JgNkg3yjq88TLesB63B6nvug,128586
+mainsequence/cli/api.py,sha256=V_unMemgLaI3PhlhQ3cKngWPMczqwr6QJwbFVBE_55s,128597
 mainsequence/cli/browser_auth.py,sha256=C-Sbpt0Pr9Pv3Z9dO80TMk7zPcaaZ-4zvW0tbRVMrTU,9863
-mainsequence/cli/cli.py,sha256=JnueoyzZ0t99m7RIwmeUNWYNPUo8gNntpcBeaL0bERk,276172
+mainsequence/cli/cli.py,sha256=3cL5Xjp6TGgfuBeOHSEoOm5jOH7fEFblla70vTSiX8A,276184
 mainsequence/cli/code_repository_status.py,sha256=SHEnU8YSWFowPG6dEdE4Yd8CS1tIcJSE1MXFLfvD3Os,5975
 mainsequence/cli/config.py,sha256=4AGDEUPAJ1GzoDX3FzYYFvGMKfeAXM38Kh7Yv-OQLQQ,45595
 mainsequence/cli/docker_utils.py,sha256=eAnp9MI042cHWwKasA5IF2I7INL3A6tV2JX-cSIe7rc,10687
@@ -32,13 +33,14 @@ mainsequence/cli/pydantic_cli.py,sha256=zmFNYv14NrjgXbOszY9qmzDBu-0-J5S2Ado-eMII
 mainsequence/cli/sdk_utils.py,sha256=SFuSzh8WDNf21mLiDa51K8Fqe5XiLWh2KhHj8zUjCXo,2701
 mainsequence/cli/ssh_utils.py,sha256=XznLkntuw7HklfuoJax3OpJY2ccsxQHOUBzZtAl05Kc,13472
 mainsequence/cli/ui.py,sha256=memd6pmjALfGj8zndGCx_z80ztQeqTcOvcofU0un34U,2277
-mainsequence/client/__init__.py,sha256=nNIeXZtubP1ULdYfnm2Ramm4OwpU8ySlpBy-s9ikiSs,372
+mainsequence/client/__init__.py,sha256=lsr9JWxeVqOG0KRoHErW5M40ACPSR7SAEE508dTN5XM,672
 mainsequence/client/agent_runtime_models.py,sha256=lay0DN3lN5p6-3ajVsaHvPgcmrURFwrNfTb6upoImm4,66642
 mainsequence/client/base.py,sha256=T3k3xptM09TreiVogrxAPWoIy8zM6Dtn3Cbwsnb33ag,42678
 mainsequence/client/client.py,sha256=sUsJhjwKq4oZsEX2Ozm-7owcyQq0kgFNKUrtEYwf8cU,3907
 mainsequence/client/compute_validation.py,sha256=ByeX0CkIE7qq06ggZFfN92U3Qp2e9cvo2RTIGWa5_Vw,6662
 mainsequence/client/exceptions.py,sha256=xx2L4l3OMNsTybbYkiTKK398ahnutEascM0It35tGr0,3815
 mainsequence/client/github_issues.py,sha256=pSTUw3UPrmE6wqnpoJctartTaNSq6iu6PQRrd8hip6I,14568
+mainsequence/client/inference.py,sha256=iMg3l5DGW6PQeVkz38Z3lTpxryMO14CTK6gIRHLYUBE,7368
 mainsequence/client/models_foundry.py,sha256=iN1jJzDokfniEQF0Ac5eepAB7L5pVjJnKavaHLP7BHA,36310
 mainsequence/client/models_helpers.py,sha256=rE7wPc9llKkctAKdJcak0kXJagjLivUzO2ebUGhz1M8,45820
 mainsequence/client/models_user.py,sha256=BU_hfn4-4KqYz3nsaPlXuYZmUG6_-7YM892mkM92Zyo,37613
@@ -50,9 +52,9 @@ mainsequence/instrumentation/utils.py,sha256=b-ihjSioAepeLfMpudM2SqCtvnxMqIXileH
 mainsequence/server/__init__.py,sha256=559DiiBcCP6veWRmK2mXUEbsl7gbZofTvsbTUFjn0VE,82
 mainsequence/server/caller_assertions.py,sha256=5q8LZrDYozaonG1eBb9P8DojKQlB2i2qUJwO5VhsrW4,9780
 mainsequence/server/fastapi.py,sha256=tD1aVuJOgoBTu7H8bs9IldPNYRT4fhkr1leN3KZP1pI,10521
-mainsequence-9.0.2.dev32.dist-info/licenses/LICENSE,sha256=b6Ecsk8wjsEby3lbSzdljR6hHiFGHBizt9iWV2p1c_I,1074
-mainsequence-9.0.2.dev32.dist-info/METADATA,sha256=m2rgtp3Cz2nDtlUChD40l1GN8z3VdQcl0pykNLdxDGo,7435
-mainsequence-9.0.2.dev32.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-mainsequence-9.0.2.dev32.dist-info/entry_points.txt,sha256=XGAOq3-mF2lWWpeRJvoaWyMarRcK167mH1g124aGdUs,88
-mainsequence-9.0.2.dev32.dist-info/top_level.txt,sha256=BFeblM_Q9q0cUWBvTxnfWcWQEHtf5XZi9nOS-Gdfwus,28
-mainsequence-9.0.2.dev32.dist-info/RECORD,,
+mainsequence-9.0.3.dev33.dist-info/licenses/LICENSE,sha256=b6Ecsk8wjsEby3lbSzdljR6hHiFGHBizt9iWV2p1c_I,1074
+mainsequence-9.0.3.dev33.dist-info/METADATA,sha256=GlRgiFfjsEHypd6iSEZdjUqr4hEBQeBOLfYljbg_9Ec,7435
+mainsequence-9.0.3.dev33.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+mainsequence-9.0.3.dev33.dist-info/entry_points.txt,sha256=XGAOq3-mF2lWWpeRJvoaWyMarRcK167mH1g124aGdUs,88
+mainsequence-9.0.3.dev33.dist-info/top_level.txt,sha256=BFeblM_Q9q0cUWBvTxnfWcWQEHtf5XZi9nOS-Gdfwus,28
+mainsequence-9.0.3.dev33.dist-info/RECORD,,