mainsequence 9.0.2.dev32__tar.gz → 9.0.3.dev33__tar.gz

{mainsequence-9.0.2.dev32/mainsequence.egg-info → mainsequence-9.0.3.dev33}/PKG-INFO

@@ -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 → mainsequence-9.0.3.dev33}/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

mainsequence-9.0.3.dev33/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.

{mainsequence-9.0.2.dev32 → mainsequence-9.0.3.dev33}/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-9.0.2.dev32 → mainsequence-9.0.3.dev33}/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-9.0.2.dev32 → mainsequence-9.0.3.dev33}/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-9.0.2.dev32 → mainsequence-9.0.3.dev33}/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-9.0.3.dev33/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 → mainsequence-9.0.3.dev33/mainsequence.egg-info}/PKG-INFO

@@ -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 → mainsequence-9.0.3.dev33}/mainsequence.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 agent_scaffold/AGENTS.md
 agent_scaffold/skills/a2a_sdk_execution/SKILL.md
 agent_scaffold/skills/application_surfaces/api_surfaces/SKILL.md
+agent_scaffold/skills/mainsequence-inference/SKILL.md
 agent_scaffold/skills/maintenance/bug_auditor/SKILL.md
 agent_scaffold/skills/maintenance/code_repository_maintenance/SKILL.md
 agent_scaffold/skills/maintenance/metatables_transition/SKILL.md
@@ -48,6 +49,7 @@ mainsequence/client/client.py
 mainsequence/client/compute_validation.py
 mainsequence/client/exceptions.py
 mainsequence/client/github_issues.py
+mainsequence/client/inference.py
 mainsequence/client/models_foundry.py
 mainsequence/client/models_helpers.py
 mainsequence/client/models_user.py
@@ -80,6 +82,7 @@ tests/test_fastapi_request_identity.py
 tests/test_filter_normalization.py
 tests/test_github_issues_client.py
 tests/test_independent_context.py
+tests/test_inference_client.py
 tests/test_instrumentation.py
 tests/test_job_client.py
 tests/test_local_ops.py

{mainsequence-9.0.2.dev32 → mainsequence-9.0.3.dev33}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mainsequence"
-version = "9.0.2.dev32"
+version = "9.0.3.dev33"
 description = "Main Sequence SDK"
 readme = "README.md"
 requires-python = ">=3.13"

{mainsequence-9.0.2.dev32 → mainsequence-9.0.3.dev33}/tests/test_cli.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import dataclasses
+import datetime
 import hashlib
 import importlib
 import json
@@ -8,8 +10,11 @@ import pathlib
 import subprocess
 import sys
 import types
+from enum import Enum
+from uuid import UUID
 
 import pytest
+from pydantic import BaseModel
 from typer.testing import CliRunner
 
 USER_UID = "8f5d6b54-2f5e-4a8b-bb10-0b17f3f4c123"
@@ -217,6 +222,102 @@ def test_user_show_json(cli_mod, runner, monkeypatch):
     assert payload["organization"]["name"] == "Main Sequence"
 
 
+@pytest.mark.parametrize("json_output", [False, True])
+def test_user_show_handles_nested_uuid_identity(cli_mod, runner, monkeypatch, json_output):
+    organization_uid = "00000000-0000-4000-8000-000000000002"
+    identity = {
+        "uid": UUID(USER_UID),
+        "username": "jose",
+        "organization": {"uid": UUID(organization_uid), "name": "Main Sequence"},
+        "active_team_uids": [UUID(TEAM_UID)],
+    }
+    monkeypatch.setattr(cli_mod, "get_logged_user_details", lambda: identity)
+
+    result = runner.invoke(cli_mod.app, ["user"] + (["--json"] if json_output else []))
+
+    assert result.exit_code == 0
+    if json_output:
+        assert json.loads(result.output) == {
+            "uid": USER_UID,
+            "username": "jose",
+            "organization": {"uid": organization_uid, "name": "Main Sequence"},
+            "active_team_uids": [TEAM_UID],
+        }
+    else:
+        assert USER_UID in result.output
+        assert "Main Sequence" in result.output
+
+
+def test_to_jsonable_normalizes_uuid_in_nested_containers(cli_mod):
+    @dataclasses.dataclass
+    class Identity:
+        uid: UUID
+
+    class IdentityModel(BaseModel):
+        uid: UUID
+
+    class State(Enum):
+        ACTIVE = "active"
+
+    uid = UUID(USER_UID)
+    joined = datetime.datetime(2026, 1, 1, tzinfo=datetime.UTC)
+    payload = {
+        "uid": uid,
+        "nested": {"uid": uid, "orm_class": object()},
+        "list": [uid],
+        "tuple": (uid,),
+        "set": {uid},
+        "dataclass": Identity(uid),
+        "model": IdentityModel(uid=uid),
+        "indexed": {uid: uid},
+        "date_joined": joined,
+        "path": pathlib.Path("skills"),
+        "state": State.ACTIVE,
+        "orm_class": object(),
+    }
+
+    assert json.loads(json.dumps(cli_mod._to_jsonable(payload))) == {
+        "uid": USER_UID,
+        "nested": {"uid": USER_UID},
+        "list": [USER_UID],
+        "tuple": [USER_UID],
+        "set": [USER_UID],
+        "dataclass": {"uid": USER_UID},
+        "model": {"uid": USER_UID},
+        "indexed": {USER_UID: USER_UID},
+        "date_joined": joined.isoformat(),
+        "path": "skills",
+        "state": "active",
+    }
+
+
+def test_to_jsonable_does_not_hide_unsupported_type_errors(cli_mod):
+    with pytest.raises(TypeError, match="not JSON serializable"):
+        json.dumps(cli_mod._to_jsonable(object()))
+
+
+@pytest.mark.parametrize("json_output", [False, True])
+@pytest.mark.parametrize(
+    ("error_type", "message", "expected_message"),
+    [
+        ("NotLoggedIn", "Invalid session", "Not logged in. Run: mainsequence login"),
+        ("ApiError", "Current user unavailable", "Current user unavailable"),
+    ],
+)
+def test_user_show_preserves_errors(
+    cli_mod, runner, monkeypatch, json_output, error_type, message, expected_message
+):
+    def rejected():
+        raise getattr(cli_mod, error_type)(message)
+
+    monkeypatch.setattr(cli_mod, "get_logged_user_details", rejected)
+
+    result = runner.invoke(cli_mod.app, ["user"] + (["--json"] if json_output else []))
+
+    assert result.exit_code == 1
+    assert expected_message in result.output
+
+
 def test_skills_list(cli_mod, runner, monkeypatch, tmp_path):
     bundle_dir = tmp_path / "agent_scaffold"
     (bundle_dir / "skills" / "code_repository_design").mkdir(parents=True)
@@ -4134,9 +4235,34 @@ def test_validate_code_repository_name_uses_client_model(cli_mod, monkeypatch):
     assert out["normalized"]["repository_library_name"] == "rates_platform"
 
 
-def test_get_logged_user_details_uses_canonical_authenticated_user_method(cli_mod, monkeypatch):
+def test_get_logged_user_details_uses_canonical_authenticated_user_method(
+    cli_mod, runner, monkeypatch
+):
+    from mainsequence.client.models_user import User
+
     api_mod = importlib.import_module("mainsequence.cli.api")
     captured = {}
+    user = User.model_validate(
+        {
+            "id": 7,
+            "uid": USER_UID,
+            "username": "jose",
+            "email": "jose@main-sequence.io",
+            "date_joined": "2026-01-01T00:00:00Z",
+            "is_active": True,
+            "api_request_limit": 10000,
+            "mfa_enabled": False,
+            "active_team_uids": [TEAM_UID],
+            "organization": {
+                "id": 2,
+                "uid": "00000000-0000-4000-8000-000000000003",
+                "name": "Main Sequence",
+                "organization_domain": "main-sequence.io",
+                "production_environment_uid": "00000000-0000-4000-8000-000000000002",
+            },
+        }
+    )
+    assert isinstance(user.model_dump()["active_team_uids"][0], UUID)
 
     monkeypatch.setattr(
         api_mod, "get_tokens", lambda: {"access": "acc", "refresh": "ref", "username": "u"}
@@ -4182,20 +4308,7 @@ def test_get_logged_user_details_uses_canonical_authenticated_user_method(cli_mo
         @classmethod
         def get_authenticated_user_details(cls):
             captured["current_user_url"] = f"{cls.ROOT_URL}/users/me/"
-            return types.SimpleNamespace(
-                model_dump=lambda: {
-                    "id": 7,
-                    "uid": "user-uid-7",
-                    "username": "jose",
-                    "email": "jose@main-sequence.io",
-                    "organization": {
-                        "id": 2,
-                        "uid": "org-uid-2",
-                        "name": "Main Sequence",
-                        "production_environment_uid": ("00000000-0000-4000-8000-000000000002"),
-                    },
-                }
-            )
+            return user
 
     fake_base.BaseObjectOrm = FakeBaseObjectOrm
     fake_models_user.User = FakeUser
@@ -4215,12 +4328,31 @@ def test_get_logged_user_details_uses_canonical_authenticated_user_method(cli_mo
     assert captured["current_user_url"] == "https://backend.test/api/v1/users/me/"
     assert "id" not in out
     assert "id" not in out["organization"]
-    assert out["uid"] == "user-uid-7"
+    assert out["uid"] == USER_UID
     assert out["username"] == "jose"
+    assert out["active_team_uids"] == [TEAM_UID]
+    assert json.loads(json.dumps(out))["uid"] == USER_UID
     assert (
         out["organization"]["production_environment_uid"] == "00000000-0000-4000-8000-000000000002"
     )
 
+    normal = runner.invoke(cli_mod.app, ["user"])
+    structured = runner.invoke(cli_mod.app, ["user", "--json"])
+
+    assert normal.exit_code == structured.exit_code == 0
+    assert USER_UID in normal.output
+    assert "Main Sequence" in normal.output
+    payload = json.loads(structured.output)
+    assert payload["uid"] == out["uid"]
+    assert payload["organization"]["uid"] == out["organization"]["uid"]
+    assert payload["active_team_uids"] == [TEAM_UID]
+    assert "id" not in payload
+    assert "id" not in payload["organization"]
+    assert "user_permissions" not in payload
+    assert "orm_class" not in payload
+    assert '"acc"' not in structured.output
+    assert '"ref"' not in structured.output
+
 
 def test_search_code_repositories_uses_client_model(cli_mod, monkeypatch):
     api_mod = importlib.import_module("mainsequence.cli.api")

mainsequence-9.0.3.dev33/tests/test_inference_client.py

@@ -0,0 +1,167 @@
+from contextlib import nullcontext
+from unittest.mock import Mock
+
+import pytest
+import requests
+
+from mainsequence.client import inference
+
+ENVIRONMENT = "00000000-0000-4000-8000-000000000001"
+CONVERSATION = "00000000-0000-4000-8000-000000000002"
+REQUEST = "00000000-0000-4000-8000-000000000003"
+
+
+def result(**extra):
+    return {
+        "conversation_uid": CONVERSATION,
+        "request_uid": REQUEST,
+        "sequence": 1,
+        "provider": "openai",
+        "model": "configured-model",
+        "status": "completed",
+        "error_code": "",
+        "content_available": True,
+        "usage": {"complete": False},
+        **extra,
+    }
+
+
+@pytest.fixture
+def transport(monkeypatch):
+    session = Mock()
+    response = Mock(status_code=200)
+    response.json.return_value = result()
+    session.request.return_value = response
+    factory = Mock(return_value=nullcontext(session))
+    monkeypatch.setattr(inference.utils, "build_session", factory)
+    monkeypatch.setattr(
+        inference.utils.loaders,
+        "refresh_headers",
+        Mock(return_value={"Authorization": "test-auth"}),
+    )
+    monkeypatch.setattr(inference.utils, "API_ENDPOINT", "https://mainsequence.test/api/v1")
+    return session, response, factory
+
+
+@pytest.mark.parametrize(
+    "provider,options",
+    [
+        ("openai", {"store": False, "text": {"verbosity": "low"}}),
+        ("anthropic", {"thinking": {"type": "adaptive"}, "output_config": {"effort": "high"}}),
+        ("ollama-local", {"reasoning_effort": "high"}),
+        ("openrouter", {"provider": {"zdr": True}, "reasoning": {"effort": "high"}}),
+    ],
+)
+def test_native_options_survive_for_each_provider(transport, provider, options):
+    options["future_field"] = [None, False, {"new": "value"}]
+    session, response, factory = transport
+    client = inference.InferenceClient(organization_environment_uid=ENVIRONMENT)
+    answer = client.complete(
+        provider=provider,
+        model="configured-model",
+        messages=[{"role": "user", "content": "test"}],
+        idempotency_key="one",
+        provider_options=options,
+    )
+    assert answer.request_uid == REQUEST
+    kwargs = session.request.call_args.kwargs
+    assert kwargs["json"]["provider_options"] == options
+    assert "thinking_level" not in kwargs["json"]
+    assert kwargs["headers"]["Idempotency-Key"] == "one"
+    assert kwargs["params"]["organization_environment_uid"] == ENVIRONMENT
+    assert factory.call_args.kwargs["retries"] == 0
+
+
+def test_common_controls_and_retry_identity(transport):
+    session, _, _ = transport
+    client = inference.InferenceClient()
+    kwargs = dict(
+        provider="openai",
+        model="configured-model",
+        messages=[],
+        idempotency_key="stable",
+        thinking_level="high",
+        provider_storage={"store_response": False},
+        provider_options={"future": None},
+    )
+    client.complete(**kwargs)
+    first = session.request.call_args
+    client.complete(**kwargs)
+    assert session.request.call_args == first
+    assert first.kwargs["json"]["thinking_level"] == "high"
+    assert first.kwargs["json"]["provider_storage"] == {"store_response": False}
+
+
+def test_timeout_does_not_retry_or_create_a_new_key(transport):
+    session, _, _ = transport
+    session.request.side_effect = requests.Timeout()
+    with pytest.raises(inference.InferenceTransportError) as exc:
+        inference.InferenceClient().complete(
+            provider="openai", model="configured-model", messages=[], idempotency_key="stable"
+        )
+    assert exc.value.idempotency_key == "stable"
+    assert session.request.call_count == 1
+
+
+def test_recorded_failure_preserves_identifiers(transport):
+    session, response, _ = transport
+    response.status_code = 504
+    response.json.return_value = result(status="unknown", error_code="provider_outcome_unknown")
+    with pytest.raises(inference.InferenceExecutionError) as exc:
+        inference.InferenceClient().complete(
+            provider="openai", model="configured-model", messages=[], idempotency_key="stable"
+        )
+    assert exc.value.result.request_uid == REQUEST
+    assert session.request.call_count == 1
+
+
+@pytest.mark.parametrize(
+    "method,path",
+    [
+        ("conversation", ""),
+        ("history", "history/"),
+        ("insights", "insights/"),
+        ("delete_content", "content/"),
+    ],
+)
+def test_history_operations_use_mainsequence_and_exact_uid(transport, method, path):
+    session, _, _ = transport
+    getattr(inference.InferenceClient(organization_environment_uid=ENVIRONMENT), method)(
+        CONVERSATION
+    )
+    assert (
+        session.request.call_args.args[1]
+        == f"https://mainsequence.test/api/v1/inference/conversations/{CONVERSATION}/{path}"
+    )
+    assert session.request.call_args.args[0] == ("DELETE" if method == "delete_content" else "GET")
+
+
+def test_authentication_refresh_keeps_body_and_key(transport):
+    session, response, _ = transport
+    refused = Mock(status_code=401)
+    session.request.side_effect = [refused, response]
+    inference.InferenceClient().complete(
+        provider="openai", model="configured-model", messages=[], idempotency_key="stable"
+    )
+    assert session.request.call_count == 2
+    assert (
+        session.request.call_args_list[0].kwargs["json"]
+        == session.request.call_args_list[1].kwargs["json"]
+    )
+    assert session.request.call_args_list[1].kwargs["headers"]["Idempotency-Key"] == "stable"
+
+
+@pytest.mark.parametrize("invalid", ["html", {}, {"request_uid": REQUEST}])
+def test_invalid_success_is_uncertain_and_never_retried(transport, invalid):
+    session, response, _ = transport
+    if invalid == "html":
+        response.json.side_effect = ValueError("Non-JSON reply")
+    else:
+        response.json.return_value = invalid
+    with pytest.raises(inference.InferenceTransportError) as exc:
+        inference.InferenceClient().complete(
+            provider="openai", model="configured-model", messages=[], idempotency_key="stable"
+        )
+    assert exc.value.idempotency_key == "stable"
+    assert session.request.call_count == 1
+    assert session.request.call_args.kwargs["allow_redirects"] is False

{mainsequence-9.0.2.dev32 → mainsequence-9.0.3.dev33}/tests/test_scaffold_skills.py

@@ -250,6 +250,7 @@ def test_packaged_scaffold_keeps_retained_sdk_skills():
 
     assert skill_paths == {
         "a2a_sdk_execution/SKILL.md",
+        "mainsequence-inference/SKILL.md",
         "application_surfaces/api_surfaces/SKILL.md",
         "maintenance/bug_auditor/SKILL.md",
         "maintenance/code_repository_maintenance/SKILL.md",