@sogni-ai/sogni-client 4.2.0-alpha.25 → 4.2.0-alpha.26

package/{CLAUDE.md → AGENTS.md}

@@ -1,6 +1,6 @@
-# CLAUDE.md
+# AGENTS.md
 
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+This file provides guidance to AI coding assistants (Claude Code, Codex, etc.) when working with code in this repository.
 
 ## LLM Documentation Resources
 
@@ -13,31 +13,49 @@ For AI coding assistants working with this SDK, the following resources are avai
 
 When helping users with Sogni SDK tasks, consult `llms-full.txt` for complete parameter references, especially for video generation where WAN 2.2 and LTX-2.3 models have different behaviors.
 
-## Creative Agent Shared Contracts
+These are public agent-facing docs shipped with the npm package. They are kept aligned with:
 
-Hosted chat tools, creative-agent workflow helpers, generated tool manifests, and SDK-facing workflow docs should stay aligned with `../sogni-creative-agent`. Do not recreate chat-only or SDK-only regex guardrails for tool argument repair, storyboard planning, or workflow routing. Add reusable JSON schemas, typed repair/control semantics, and deterministic validation to the shared package first, then regenerate or copy the public SDK artifacts as appropriate.
+- `package.json` for package version, runtime engines, npm scripts, exports, and published files.
+- `src/index.ts` for public SDK namespaces and root exports.
+- `src/Projects/types/index.ts`, `src/Projects/utils/index.ts`, and `src/Projects/createJobRequestMessage.ts` for media-generation parameters and video frame behavior.
+- `src/Chat/types.ts`, `src/Chat/index.ts`, `src/Chat/tools.ts`, and `src/Chat/hostedToolValidation.generated.ts` for chat, hosted tools, structured outputs, and durable runs.
+- `src/CreativeWorkflows/` and `src/Replay/` for durable workflow and RunRecord APIs.
 
-Use secondary LLM calls for semantic planning, creative adaptation, and audit/repair workflows, not as a substitute for schema validation of tool arguments or structured workflow control.
+Current public API anchors:
 
-When SDK examples or generated helpers expose hosted creative workflows, keep them generated from or aligned with shared `@sogni/creative-agent` contracts such as `compileCreativeWorkflowPlanToHostedSequence()`, `validateAndNormalizeHostedToolArguments()`, `getRepairControlDecision()`, and `summarizeGuardTelemetry()`.
+- The SDK runtime requirement is **Node.js >=22** (`package.json#engines`).
+- Socket-native LLM chat uses `sogni.chat.completions.create()`.
+- Durable creative workflows use `sogni.workflows`.
+- Project cost helpers are `sogni.projects.estimateCost()`, `estimateVideoCost()`, and `estimateAudioCost()`.
+- `checkAuth()` is only for cookie-auth browser flows. API-key auth auto-authenticates during `createInstance()`, and token auth uses `login()` or `setTokens()`.
+- `ChatCompletionResult` is SDK-shaped (`content`, `role`, `finishReason`, `tool_calls`, `usage`, `cost`). Streaming chunks expose `chunk.content` and optional `chunk.tool_calls`.
 
-### Shared `@sogni/creative-agent` contracts
+## Sogni Intelligence APIs
 
-`@sogni/creative-agent` ships several surfaces SDK consumers can import directly when implementing creative workflows:
+The SDK wraps the public Sogni Intelligence endpoints used for text chat, hosted creative tools, durable chat turns, and deterministic multi-step workflows.
 
-- **Per-turn tool gating**: the chat-side skill loader (`load_skill` / `unload_skill` / `list_active_skills`) was retired on 2026-05-10. Tool-surface composition is now owned by Structured Contracts v1 (see next bullet). SDK consumers building their own agent loop should construct a `ContractRegistry` and call `classifyTurn` / `compileToolsForTurn` / `dispatchToolCall` instead of advertising load/unload tools to the model. (The read-only `*_SKILL` manifest metadata used by the public Anthropic-style skill artifact is **not** a `@sogni/creative-agent` package export — it ships separately via `@sogni-ai/sogni-creative-agent-skill`.)
-- **Structured Contracts v1**: `ContractRegistry`, `ToolGatingPolicy`, `RepairRecipe`, `PromptContract`, `classifyTurn`, `compileToolsForTurn`, `dispatchToolCall`, plus the `ContractsTelemetrySink` event types. The chat product seeds a registry once per session and the three evaluators own visible-tool composition, repair-on-error, and prompt-bake.
-- **Asset manifest**: `createAssetManifest`, `addAsset`, `mapAssetsForModel`, `validateAssetReferences`, `formatModelRef` — three-layer asset references (`asset_id` / `user_label` / `model_ref`) so SDK consumers don't hand-format Seedance `@Image1` / GPT-Image-2 `[Image 1]` / LTX-2.3 `context_image_0` tokens.
-- **Storyboard adapters**: `compileForModel`, `storyboardAdapterRegistry`, `SEEDANCE_ADAPTER`, `GPT_IMAGE_2_ADAPTER`, `LTX23_ADAPTER`, `WAN_ADAPTER`. Resolution is liberal (`seedance2-fast` → seedance via prefix).
-- **Tool envelope**: `ToolResult`, `toolOk`, `toolErr`, `isToolResultOk`, `isToolResultErr`, `mapLegacyToolErrorCategory`, plus the canonical `ToolErrorCode` taxonomy.
-- **Constrained decoding (`response_format`)**: llama-server natively accepts OpenAI-standard `{ type: "json_schema", json_schema: { strict, schema } }`. Plumbed through `src/Chat/index.ts` and forwarded to the worker via `sogni-socket` (commit `b711a68`); the `ChatResponseFormat` type is re-exported from the SDK root for typed consumer usage.
-- **Default contract data**: `populateContractsDefaults(registry)` seeds a `ContractRegistry` with the canonical Phase 3 gating policies (7), Phase 4 repair recipes (157 across 11 `(toolName, ToolErrorCode)` families), and Phase 5 per-tool prompt contracts (12). SDK consumers calling `classifyTurn` / `compileToolsForTurn` / `dispatchToolCall` should seed off this one call instead of registering policies / recipes / contracts manually.
-- **Per-tool cost + permission**: `getToolCostMetadata(toolName)` returns `{ costClass, riskLevel, userVisibleCost, description }`; `getToolPermission(toolName)` returns the typed `ToolPermissionDecision` (`allow` / `require_user_approval` / `require_explicit_intent`). SDK consumers can use these for client-side billing UX or for enforcing destructive-tool gates in their own agent loop (chat + hosted both enforce `require_explicit_intent` via shared `EXPLICIT_INTENT_PATTERNS`).
-- **Replay record schema**: `RunRecord` (schema v2; `skills_loaded` dropped after the 2026-05-10 skill-loader retirement), `redactRunRecord`, `emptyRunRecord`, plus the canonical `RunRecordToolCall` / `RunRecordToolResult` / `RunRecordRound` / `RunRecordAuditResult` shapes. SDK consumers that emit their own RunRecord (instead of relying on sogni-chat) should call `redactRunRecord` defense-in-depth before persisting / posting. The chat product writes records to sogni-api's `POST /v1/replay/records` ingest endpoint; SDK consumers can POST the same shape to the same endpoint with their api-key auth.
+- `sogni.chat.completions.create()` maps to socket-native chat completions and supports text, streaming, vision input, custom function tools, Sogni tool injection, structured outputs, and `think` / `taskProfile` controls.
+- `sogni.chat.hosted.create()` maps to `POST /v1/chat/completions`, the OpenAI-compatible REST chat endpoint. It can execute Sogni media-generation and composition tools server-side.
+- `sogni.chat.runs` maps to `/v1/chat/runs`, a durable hosted-chat turn with persisted state, event replay, cancellation, and recovery across client disconnects.
+- `sogni.workflows` maps to `/v1/creative-agent/workflows`, where callers submit exact multi-step creative plans and observe durable execution through snapshots, event logs, or SSE.
+- `sogni.workflows.templates` maps to `/v1/creative-agent/workflows/templates`, the CRUD and fork API for saved, parameterized workflow recipes.
+- `sogni.replay` maps to `/v1/replay/records`, the RunRecord write/list/get surface for replay viewers and audit tooling.
+
+Public chat and workflow media rules:
+
+- Vision chat accepts inline PNG or JPEG `data:` URIs through OpenAI-style `image_url` content parts.
+- Durable chat runs and creative workflows use retrievable HTTP(S) media references, often produced by Sogni upload/download URL helpers.
+- Request media references are addressable by media index in hosted tool and workflow calls, so later steps can reuse uploaded or generated images, videos, and audio without copying URLs into prompts.
 
 ## Overview
 
-This is the **Sogni SDK for JavaScript/Node.js** - a TypeScript client library for the Sogni Supernet, a DePIN protocol for creative AI inference. The SDK supports image generation (Stable Diffusion, Flux, etc.), video generation (WAN 2.2 and LTX-2.3 models), audio generation (ACE-Step 1.5), LLM chat with tool calling, and multimodal vision chat (Qwen3.6 35B VLM, default `qwen3.6-35b-a3b-gguf-iq4xs`) via WebSocket communication.
+This is the **Sogni SDK for JavaScript/Node.js** - a TypeScript client library for the Sogni Supernet, a DePIN protocol for creative AI inference. The SDK supports image generation (Stable Diffusion, Flux, Z-Image, Qwen image-edit models, GPT Image 2), video generation (WAN 2.2, LTX-2.3, Seedance 2.0), audio generation (ACE-Step 1.5), LLM chat with tool calling, hosted creative tools, durable creative workflows, replay records, and multimodal vision chat (Qwen3.6 35B VLM, default `qwen3.6-35b-a3b-gguf-iq4xs`).
+
+Runtime and packaging:
+
+- Node.js `>=22` is required by `package.json`.
+- CommonJS build: `dist/index.js`; ESM build: `dist-esm/index.js`; type declarations: `dist/index.d.ts`.
+- Published package files include `README.md`, `AGENTS.md`, `llms.txt`, `llms-full.txt`, `dist/`, `dist-esm/`, and `src/`.
 
 ## Build & Development Commands
 
@@ -54,10 +72,26 @@ npm run prettier:fix
 # Check formatting
 npm run prettier
 
+# Validate generated hosted-tool validation file is in sync
+npm run check:hosted-tool-validation
+
+# Validate generated hosted-tool manifest is in sync
+npm run check:hosted-tools-manifest
+
+# Build and run chat model-routing checks
+npm run test:chat-routing
+
 # Generate API documentation
 npm run docs
 ```
 
+Generated artifacts:
+
+- `src/Chat/sogniHostedTools.generated.json` is regenerated with `npm run sync:hosted-tools-manifest`.
+- `src/Chat/hostedToolValidation.generated.ts` is regenerated with `npm run sync:hosted-tool-validation`.
+- `docs/` is generated by TypeDoc via `npm run docs`.
+- `dist/` and `dist-esm/` are generated by `npm run build`.
+
 ## Architecture
 
 ### Entry Point & Main Classes
@@ -71,8 +105,10 @@ npm run docs
   - `chat.hosted.create` - Hosted synchronous chat via `/v1/chat/completions`
   - `chat.runs.{create, get, cancel, streamEvents}` - Durable hosted chat runs via `/v1/chat/runs` with SSE replay
   - `chat.tools` - Tool helpers (build, parse, validate)
-- `creativeWorkflows: CreativeWorkflowsApi` - Durable explicit creative workflows via `/v1/creative-agent/workflows`
-- `workflows: CreativeWorkflowsApi` - Flat alias of `creativeWorkflows` for shorter call sites
+- `workflows: CreativeWorkflowsApi` - Durable explicit creative workflows via `/v1/creative-agent/workflows`
+  - `workflows.{start, list, get, events, streamEvents, resume, reseed, cancel}`
+  - `workflows.templates.{list, get, create, update, delete, fork}`
+- `replay: ReplayApi` - RunRecord write/list/get via `/v1/replay/records`
 - `apiClient: ApiClient` - Internal REST + WebSocket communication
 
 ### Core Entity Hierarchy
@@ -100,6 +136,9 @@ src/
 │   └── utils/            # Samplers, schedulers
 ├── Account/              # User auth & balance (CurrentAccount entity)
 ├── Stats/                # Leaderboard API
+├── Chat/                 # Socket chat, hosted REST chat, durable runs, hosted tools
+├── CreativeWorkflows/    # Durable explicit workflow API + template CRUD
+├── Replay/               # RunRecord ingest/list/get API
 ├── lib/                  # Shared utilities
 │   ├── AuthManager/      # Token/Cookie auth strategies
 │   ├── DataEntity.ts     # Base reactive entity
@@ -121,6 +160,19 @@ src/
 2. Server sends `jobState`, `jobProgress`, `jobResult` events → Updates Project/Job entities
 3. Entities emit events → User code receives 'progress', 'completed', 'failed'
 
+LLM chat flow:
+
+1. User calls `sogni.chat.completions.create()` → SDK sends `llmJobRequest` via WebSocket.
+2. Server streams `jobTokens` and terminal `llmJobResult` / `llmJobError` events.
+3. Streaming callers iterate `ChatStream`; non-streaming callers receive `ChatCompletionResult`.
+4. Hosted REST chat uses `sogni.chat.hosted.create()`; durable chat runs use `sogni.chat.runs`.
+
+Durable workflow flow:
+
+1. User calls `sogni.workflows.start()` with either an inline `input` plan or `workflowId` + `inputs`.
+2. REST API persists the workflow and returns a `CreativeWorkflowRecord`.
+3. Callers inspect `get()` / `events()` or consume `streamEvents()` with SSE resume support.
+
 ### Network Types
 
 - `fast` - High-end GPUs, faster but more expensive. Required for video generation.
@@ -139,9 +191,9 @@ The SDK supports two families of video models with **fundamentally different FPS
 - **Frame step constraint**: Frame count must follow pattern `1 + n*8` (i.e., 1, 9, 17, 25, 33, ...)
 - Example: 5 seconds at 24fps = 121 frames (snapped to 1 + 15*8 = 121)
 
-### Legacy Behavior (WAN 2.2 only)
+### WAN 2.2 Behavior
 
-**WAN 2.2 Models (`wan_v2.2-*`)** are the outlier with legacy behavior:
+**WAN 2.2 Models (`wan_v2.2-*`)** use a fixed internal generation rate:
 - **Always generate at 16fps internally**, regardless of the user's fps setting
 - The `fps` parameter (16 or 32) controls **post-render frame interpolation only**
 - `fps=16`: No interpolation, output matches generation (16fps)
@@ -251,7 +303,7 @@ const urls = await project.waitForCompletion();
 
 The SDK receives `LLMModelInfo` per model including `maxContextLength`, `maxOutputTokens` (min/max/default), and parameter constraints. Use these to configure `max_tokens` and display limits to users.
 
-**Caution**: `maxContextLength` from the server may not reflect the actual per-request limit on the worker (see sogni-socket and sogni-llm-nvidia CLAUDE.md for the llama-server `--parallel` slot division issue).
+Use the returned model constraints as request guidance, and prefer each model's advertised `maxOutputTokens.default` when a caller has not chosen `max_tokens`.
 
 ### Thinking Models (Qwen3.x) — `chat_template_kwargs`
 
@@ -262,7 +314,7 @@ Thinking mode is controlled via llama.cpp's `chat_template_kwargs: { enable_thin
 
 The llama-server should run with default `--reasoning-budget -1` (unrestricted) so per-request control works.
 
-Qwen3.x models generate thinking output in a separate `reasoning_content` field (OpenAI-compatible). The LLM worker wraps this in `<think>` tags inside `content` for the SDK. The SDK's `ChatCompletionChunk` type has NO `reasoning_content` field — only `content` and `tool_calls`.
+`ChatCompletionChunk` exposes generated text through `content` and tool invocations through optional `tool_calls`.
 
 **The solution for structured output**: Use **tool calling** (`tools` + `tool_choice: 'required'`). Tool call arguments are always forwarded by the worker regardless of thinking mode. The `workflow_text_chat_sogni_tools.mjs` example uses this pattern for all composition pipelines (video/image/audio prompt engineering).
 

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [4.2.0-alpha.26](https://github.com/Sogni-AI/sogni-client/compare/v4.2.0-alpha.25...v4.2.0-alpha.26) (2026-05-15)
+
+
+### Features
+
+* add replay records API ([ef98975](https://github.com/Sogni-AI/sogni-client/commit/ef98975a618523e23799aa28ab292609cbe32de6))
+
 # [4.2.0-alpha.25](https://github.com/Sogni-AI/sogni-client/compare/v4.2.0-alpha.24...v4.2.0-alpha.25) (2026-05-15)
 
 

package/README.md

@@ -851,24 +851,24 @@ const response = await sogni.chat.completions.create({
 
 ### Sogni Platform Tools — Generate Media via Chat
 
-Combine LLM intelligence with Sogni's media generation capabilities. The SDK exposes the full canonical hosted creative-tool surface — mirrored from `@sogni/creative-agent` — through `SogniTools.all` (22 tools):
+Combine LLM intelligence with Sogni's media generation capabilities. The SDK exposes the full canonical hosted creative-tool surface through `SogniTools.all` (24 tools):
 
 - **Generation** — `generate_image`, `edit_image`, `generate_video`, `sound_to_video`, `video_to_video`, `generate_music`
 - **Image adapters** — `restore_photo`, `apply_style`, `refine_result`, `change_angle`, `animate_photo` (image-to-video with multi-source fan-out)
 - **Video composition / post-production** — `stitch_video`, `orbit_video`, `dance_montage`, `extend_video`, `replace_video_segment`, `overlay_video`, `add_subtitles`
-- **Synchronous composition** — `enhance_prompt`, `compose_script`, `compose_lyrics`, `compose_instrumental`
+- **Synchronous composition and planning** — `enhance_prompt`, `compose_script`, `compose_lyrics`, `compose_instrumental`, `compose_workflow`, `compose_workflow_template`
 
 Pass `SogniTools.all` (or individual definitions like `generateImageTool`, `animatePhotoTool`, `composeScriptTool`) to an LLM via the `tools` parameter, then route tool calls through `sogni.chat.hosted.create()` / `sogni.chat.runs.create()` for server-side execution. Generated artifacts are threaded through a per-request media context so later rounds can reference earlier outputs by index (`sourceImageIndex`, `videoIndices`, `audioIndex`, etc.).
 
-For direct `/v1/chat/completions` hosted-tool execution, media-bearing tool arguments are intentionally constrained to inline `data:` URIs so the chat API remains OpenAI-compatible and does not implicitly fetch arbitrary user URLs. For user-uploaded image/audio/video inputs, use the SDK video project examples or the `sogni.creativeWorkflows` wrapper for `/v1/creative-agent/workflows`; these run outside the chat tool-selection loop and can consume HTTPS artifact URLs produced by Sogni's upload endpoints. Durable workflows validate explicit steps before the workflow starts and can bind SDK request-level `mediaReferences` into tool arguments with `sourceStepId: "$input_media"`.
+For direct `/v1/chat/completions` hosted-tool execution, media-bearing tool arguments use inline `data:` URIs. For user-uploaded image/audio/video inputs, use the SDK video project examples or the `sogni.workflows` wrapper for `/v1/creative-agent/workflows`; these can consume HTTPS artifact URLs produced by Sogni's upload endpoints. Durable workflows validate explicit steps before the workflow starts and can bind SDK request-level `mediaReferences` into tool arguments with `sourceStepId: "$input_media"`.
 
 The `workflow_text_chat_sogni_tools.mjs` example demonstrates the core text-to-image, text-to-video, and text-to-music composition flows. Dedicated workflow examples like `workflow_image_edit.mjs`, `workflow_sound_to_video.mjs`, and `workflow_video_to_video.mjs` cover the asset-backed workflows directly.
 
 ### Hosted Tool Surfaces — `sogni_tools` parameter
 
-`sogni.chat.hosted.create()` (the SDK wrapper for `/v1/chat/completions`) can inject the canonical creative-tools surface server-side via the `sogni_tools` parameter. The default `creative-tools` value injects the full media + composition + analysis surface. `sogni_tools: "creative-agent"` adds workflow control and asset-manifest tools on top.
+`sogni.chat.hosted.create()` (the SDK wrapper for `/v1/chat/completions`) can inject the canonical creative-tools surface server-side via the `sogni_tools` parameter. The default `creative-tools` value injects the full media, composition, and planning surface. `sogni_tools: "creative-agent"` adds workflow control and asset-manifest tools on top.
 
-Use default `sogni_tools: true` or `sogni_tools: "creative-tools"` when you want the full creative media tool surface plus synchronous composition tools: `enhance_prompt`, `compose_script`, `compose_lyrics`, and `compose_instrumental`. The legacy `"rich"` alias is still accepted and maps to `"creative-tools"`.
+Use default `sogni_tools: true` or `sogni_tools: "creative-tools"` when you want the full creative media tool surface plus synchronous composition tools: `enhance_prompt`, `compose_script`, `compose_lyrics`, and `compose_instrumental`.
 
 Notable creative-tools include:
 
@@ -925,17 +925,17 @@ Guided mode defaults text-to-video to `/v1/creative-agent/workflows` so the entr
 
 ### Durable Creative Workflows (server-side)
 
-Long-running multi-step creative workflows can be persisted on the server and observed independently of the chat completion that started them. The SDK exposes these API-key-only endpoints through `sogni.creativeWorkflows`:
+Long-running multi-step creative workflows can be persisted on the server and observed independently of the chat completion that started them. The SDK exposes these authenticated endpoints through `sogni.workflows`:
 
-- `sogni.creativeWorkflows.start({ input, ...options })` — start a durable workflow with an inline plan
-- `sogni.creativeWorkflows.start({ workflowId, inputs, ...options })` — run a saved workflow template by id
-- `sogni.creativeWorkflows.get(workflowId)` and `.list()` — inspect snapshots
-- `sogni.creativeWorkflows.events(workflowId)` — poll event history
-- `sogni.creativeWorkflows.streamEvents(workflowId, { after, lastEventId })` — SSE event stream with resume support
-- `sogni.creativeWorkflows.resume(workflowId)` — resume a workflow paused in `waiting_for_user`
-- `sogni.creativeWorkflows.reseed(workflowId, { seedOverrides })` — clone a completed/partial run with fresh seeds
-- `sogni.creativeWorkflows.cancel(workflowId)` — cooperative cancellation
-- `sogni.creativeWorkflows.templates.{list, get, create, update, delete, fork}` — CRUD + fork for the saved workflow templates backing `start({ workflowId })`. Also available as `sogni.workflows.templates`.
+- `sogni.workflows.start({ input, ...options })` — start a durable workflow with an inline plan
+- `sogni.workflows.start({ workflowId, inputs, ...options })` — run a saved workflow template by id
+- `sogni.workflows.get(workflowId)` and `.list()` — inspect snapshots
+- `sogni.workflows.events(workflowId)` — poll event history
+- `sogni.workflows.streamEvents(workflowId, { after, lastEventId })` — SSE event stream with resume support
+- `sogni.workflows.resume(workflowId)` — resume a workflow paused in `waiting_for_user`
+- `sogni.workflows.reseed(workflowId, { seedOverrides })` — clone a completed/partial run with fresh seeds
+- `sogni.workflows.cancel(workflowId)` — cooperative cancellation
+- `sogni.workflows.templates.{list, get, create, update, delete, fork}` — CRUD + fork for the saved workflow templates backing `start({ workflowId })`.
 
 `start()` accepts exact hosted-tool steps plus optional request-level `mediaReferences`. The SDK follows the platform camelCase style (`mediaReferences`, `tokenType`, `maxEstimatedCapacityUnits`, and `confirmCost`) and serializes the REST request to snake_case internally. A dependency with `sourceStepId: "$input_media"` can inject the matching uploaded image, video, or audio URL or index into a later step. The API validates step arguments before accepting the workflow and again before each execution step, so shape errors fail before billing later media work.
 
@@ -946,7 +946,7 @@ const sogni = await SogniClient.createInstance({
   disableSocket: true
 });
 
-const workflow = await sogni.creativeWorkflows.start({
+const workflow = await sogni.workflows.start({
   tokenType: 'spark',
   input: {
     title: 'Generated keyframe to video',
@@ -980,7 +980,7 @@ const workflow = await sogni.creativeWorkflows.start({
   },
 });
 
-for await (const event of sogni.creativeWorkflows.streamEvents(workflow.workflowId)) {
+for await (const event of sogni.workflows.streamEvents(workflow.workflowId)) {
   console.log(event.event, event.data);
 }
 ```
@@ -1064,7 +1064,7 @@ This SDK provides documentation optimized for AI coding assistants like Claude C
 | ---------------------------------- | ------------------------------------------------------- |
 | [`llms.txt`](./llms.txt)           | Indexed quick reference with code examples              |
 | [`llms-full.txt`](./llms-full.txt) | Comprehensive documentation with complete API reference |
-| [`CLAUDE.md`](./CLAUDE.md)         | Claude Code-specific guidance and project context       |
+| [`AGENTS.md`](./AGENTS.md)         | Public guidance and project context for coding agents   |
 
 These files follow the [llms.txt convention](https://llmstxt.org/) for LLM-friendly documentation.
 
@@ -1075,7 +1075,7 @@ When helping users generate images, videos, or use LLM features with Sogni:
 1. **Image generation**: Use `type: 'image'` with models like `flux1-schnell-fp8`
 2. **Video generation**: Use `type: 'video'` with `network: 'fast'` (required)
 3. **Audio generation**: Use `type: 'audio'` with ACE-Step 1.5 models
-4. **LLM text chat**: Use `sogni.projects.chatCompletion()` for text generation with streaming and tool calling
+4. **LLM text chat**: Use `sogni.chat.completions.create()` for text generation with streaming and tool calling
 5. **Sogni Platform Tools**: Combine LLM tool calling with Sogni media generation to create images, image edits, videos, audio-driven videos, video transforms, and music from natural language
 6. **Vision chat**: Use `qwen3.6-35b-a3b-gguf-iq4xs` VLM for multimodal image understanding with `image_url` content parts carrying inline base64 JPEG/PNG `data:` URIs. Vision requests allow up to 20 images, 10MB each, with longest side capped at 1024px. This 1024px dimension cap applies only to the vision `image_url` path, not to media-generation tool image inputs.
 7. **WAN 2.2, LTX-2.3, and Seedance**: These video families have different duration/FPS behaviors - see `llms-full.txt` for details

package/dist/Replay/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Replay records (`/v1/replay/records`).
+ *
+ * Phase-4 RunRecord ingestion + read. Producers (chat sessions, harness
+ * runs) `write(record)` one RunRecord per turn; consumers (the replay
+ * viewer, audit tooling) `list()` and `get(runId)` to inspect them.
+ *
+ * Auth: piggybacks on the SDK's active AuthManager (JWT for signed-in
+ * accounts, api-key for programmatic callers). The api enforces
+ * per-owner isolation via the resolved wallet address — callers can
+ * only see their own records.
+ *
+ * Errors are mapped to `ApiError` with the api's `errorCode`/`message`
+ * when present; HTTP 4xx on read becomes a thrown error so the caller
+ * can branch on status without parsing strings.
+ */
+import ApiGroup, { ApiConfig } from '../ApiGroup';
+import { GetReplayRecordResult, ListReplayRecordsOptions, ListReplayRecordsResult, ReplayRequestOptions, ReplayWriteResult, RunRecord } from './types';
+declare class ReplayApi extends ApiGroup {
+    constructor(config: ApiConfig);
+    /**
+     * POST /v1/replay/records — ingest one RunRecord. The api re-runs the
+     * redaction pass server-side as defense-in-depth, so the returned
+     * `redacted` flag reflects what was actually stored.
+     */
+    write(record: RunRecord, options?: ReplayRequestOptions): Promise<ReplayWriteResult>;
+    /**
+     * GET /v1/replay/records — paginated summary view for the caller's
+     * own records. `limit` caps results (api defaults apply when omitted).
+     */
+    list(options?: ListReplayRecordsOptions): Promise<ListReplayRecordsResult>;
+    /** GET /v1/replay/records/:id — full RunRecord for the viewer detail. */
+    get(runId: string, options?: ReplayRequestOptions): Promise<GetReplayRecordResult>;
+    private request;
+    private fetch;
+    private toApiError;
+}
+export default ReplayApi;
+export * from './types';

package/dist/Replay/index.js

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * Replay records (`/v1/replay/records`).
+ *
+ * Phase-4 RunRecord ingestion + read. Producers (chat sessions, harness
+ * runs) `write(record)` one RunRecord per turn; consumers (the replay
+ * viewer, audit tooling) `list()` and `get(runId)` to inspect them.
+ *
+ * Auth: piggybacks on the SDK's active AuthManager (JWT for signed-in
+ * accounts, api-key for programmatic callers). The api enforces
+ * per-owner isolation via the resolved wallet address — callers can
+ * only see their own records.
+ *
+ * Errors are mapped to `ApiError` with the api's `errorCode`/`message`
+ * when present; HTTP 4xx on read becomes a thrown error so the caller
+ * can branch on status without parsing strings.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ApiGroup_1 = __importDefault(require("../ApiGroup"));
+const ApiClient_1 = require("../ApiClient");
+function parseJsonResponse(text) {
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch (_a) {
+        return { status: 'error', message: text, errorCode: 0 };
+    }
+}
+class ReplayApi extends ApiGroup_1.default {
+    constructor(config) {
+        super(config);
+    }
+    /**
+     * POST /v1/replay/records — ingest one RunRecord. The api re-runs the
+     * redaction pass server-side as defense-in-depth, so the returned
+     * `redacted` flag reflects what was actually stored.
+     */
+    write(record_1) {
+        return __awaiter(this, arguments, void 0, function* (record, options = {}) {
+            var _a;
+            const body = yield this.request('/v1/replay/records', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(record),
+                signal: options.signal
+            });
+            if (typeof body.runId !== 'string') {
+                throw new ApiClient_1.ApiError(500, {
+                    status: 'error',
+                    message: 'Replay write response missing runId',
+                    errorCode: 0
+                });
+            }
+            return {
+                runId: body.runId,
+                schemaVersion: (_a = body.schemaVersion) !== null && _a !== void 0 ? _a : 0,
+                redacted: body.redacted === true,
+                createTime: typeof body.createTime === 'number' ? body.createTime : 0,
+                updateTime: typeof body.updateTime === 'number' ? body.updateTime : 0
+            };
+        });
+    }
+    /**
+     * GET /v1/replay/records — paginated summary view for the caller's
+     * own records. `limit` caps results (api defaults apply when omitted).
+     */
+    list() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            const query = new URLSearchParams();
+            if (typeof options.limit === 'number' && options.limit > 0) {
+                query.set('limit', String(Math.floor(options.limit)));
+            }
+            const path = query.toString()
+                ? `/v1/replay/records?${query.toString()}`
+                : '/v1/replay/records';
+            const body = yield this.request(path, {
+                method: 'GET',
+                signal: options.signal
+            });
+            const records = Array.isArray(body.records) ? body.records : [];
+            return { records };
+        });
+    }
+    /** GET /v1/replay/records/:id — full RunRecord for the viewer detail. */
+    get(runId_1) {
+        return __awaiter(this, arguments, void 0, function* (runId, options = {}) {
+            const body = yield this.request(`/v1/replay/records/${encodeURIComponent(runId)}`, { method: 'GET', signal: options.signal });
+            if (!body.record || typeof body.record !== 'object') {
+                throw new ApiClient_1.ApiError(500, {
+                    status: 'error',
+                    message: 'Replay get response missing record field',
+                    errorCode: 0
+                });
+            }
+            return {
+                record: body.record,
+                createTime: typeof body.createTime === 'number' ? body.createTime : 0
+            };
+        });
+    }
+    request(path_1) {
+        return __awaiter(this, arguments, void 0, function* (path, options = {}) {
+            const response = yield this.fetch(path, options);
+            if (!response.ok) {
+                throw yield this.toApiError(response);
+            }
+            const text = yield response.text();
+            return parseJsonResponse(text);
+        });
+    }
+    fetch(path_1) {
+        return __awaiter(this, arguments, void 0, function* (path, options = {}) {
+            const url = new URL(path, this.client.rest.baseUrl).toString();
+            const authenticated = yield this.client.auth.authenticateRequest(options);
+            return fetch(url, authenticated);
+        });
+    }
+    toApiError(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (response.status === 401 && this.client.auth.isAuthenticated) {
+                this.client.auth.clear();
+            }
+            const body = parseJsonResponse(yield response.text());
+            const payload = body.status === 'error' ? body : body;
+            const message = typeof payload.message === 'string' ? payload.message : response.statusText;
+            const errorCode = typeof payload.errorCode === 'number' ? payload.errorCode : 0;
+            return new ApiClient_1.ApiError(response.status, { status: 'error', message, errorCode });
+        });
+    }
+}
+exports.default = ReplayApi;
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/Replay/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/Replay/index.ts"],"names":[],"mappings":"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"}

package/dist/Replay/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Replay record types — mirrors the api `/v1/replay/records` shape.
+ *
+ * `RunRecord` is the full Phase-4 RunRecord schema. Producers serialize
+ * one per chat turn; consumers (the replay viewer, harness fixtures)
+ * read them back. The SDK keeps a structural type with the well-known
+ * envelope fields typed and the rest as `unknown` so callers that hold
+ * the richer canonical type (e.g. `@sogni/creative-agent/replay`) can
+ * cast safely without the SDK needing that dependency.
+ */
+/**
+ * RunRecord shape, kept minimal so callers that hold the richer
+ * canonical type (e.g. `RunRecord` from `@sogni/creative-agent`) pass
+ * directly without casting. No index signature — adding one would
+ * force callers to widen typed properties to `unknown` to match.
+ */
+export interface RunRecord {
+    run_id: string;
+    schema_version?: number | string;
+    session_id?: string;
+    account_id?: string;
+    model_id?: string;
+    rounds?: ReadonlyArray<unknown>;
+    user_request?: string;
+    final_response?: unknown;
+}
+export interface ReplayWriteResult {
+    runId: string;
+    schemaVersion: number | string;
+    redacted: boolean;
+    createTime: number;
+    updateTime: number;
+}
+export interface ReplayRecordSummary {
+    runId: string;
+    schemaVersion: number | string;
+    createTime: number;
+    updateTime: number;
+    userRequest?: string;
+    finalResponse?: unknown;
+    modelId?: string;
+    rounds: number;
+}
+export interface ListReplayRecordsOptions {
+    limit?: number;
+    signal?: AbortSignal;
+}
+export interface ListReplayRecordsResult {
+    records: ReplayRecordSummary[];
+}
+export interface GetReplayRecordResult {
+    record: RunRecord;
+    createTime: number;
+}
+export interface ReplayRequestOptions {
+    signal?: AbortSignal;
+}

package/dist/Replay/types.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Replay record types — mirrors the api `/v1/replay/records` shape.
+ *
+ * `RunRecord` is the full Phase-4 RunRecord schema. Producers serialize
+ * one per chat turn; consumers (the replay viewer, harness fixtures)
+ * read them back. The SDK keeps a structural type with the well-known
+ * envelope fields typed and the rest as `unknown` so callers that hold
+ * the richer canonical type (e.g. `@sogni/creative-agent/replay`) can
+ * cast safely without the SDK needing that dependency.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/Replay/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/Replay/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG"}

package/dist/index.d.ts

@@ -20,11 +20,13 @@ import CreativeWorkflowTemplatesApi from './CreativeWorkflows/Templates';
 import { CreativeWorkflowArtifact, CreativeWorkflowEvent, CreativeWorkflowRecord, CreativeWorkflowSseEvent, CreativeWorkflowStatus, CreativeWorkflowHostedToolName, ListCreativeWorkflowOptions, ReseedCreativeWorkflowOptions, ReseedCreativeWorkflowParams, ReseedCreativeWorkflowResult, ResumeCreativeWorkflowOptions, ResumeCreativeWorkflowParams, ResumeCreativeWorkflowResult, StartCreativeWorkflowOptions, StartCreativeWorkflowParams, StartCreativeWorkflowDependency, StartCreativeWorkflowInput, StartCreativeWorkflowStep, StreamCreativeWorkflowEventsOptions } from './CreativeWorkflows/types';
 import { ForkWorkflowTemplateBody, ListWorkflowTemplatesOptions, ListWorkflowTemplatesResult, WorkflowTemplate, WorkflowTemplateAuthor, WorkflowTemplateRequestOptions, WorkflowTemplateStability, WorkflowTemplateVisibility, WorkflowTemplateVisibilityFilter } from './CreativeWorkflows/Templates/types';
 import StatsApi from './Stats';
+import ReplayApi from './Replay';
+import { GetReplayRecordResult, ListReplayRecordsOptions, ListReplayRecordsResult, ReplayRecordSummary, ReplayRequestOptions, ReplayWriteResult, RunRecord } from './Replay/types';
 import ErrorData from './types/ErrorData';
 import { TokenType } from './types/token';
 import { ApiKeyAuthManager, TokenAuthData } from './lib/AuthManager';
-export type { AudioFormat, AudioOutputFormat, AudioProjectParams, AvailableModel, ChatCompletionChunk, ChatCompletionParams, ChatCompletionResult, ChatJobStateEvent, ChatMessage, ChatResponseFormat, ChatRunEvent, ChatRunRecord, ChatRunStatus, ChatTokenUsage, StartChatRunParams, StreamChatRunEventsOptions, ContentPart, HostedChatCompletionChoice, HostedChatCompletionMessage, HostedChatCompletionParams, HostedChatCompletionResult, HostedCreativeWorkflowReference, CreativeWorkflowArtifact, CreativeWorkflowEvent, CreativeWorkflowRecord, CreativeWorkflowSseEvent, CreativeWorkflowStatus, ImageUrlContentPart, ListCreativeWorkflowOptions, LLMCostEstimation, LLMJobCost, LLMModelInfo, LLMParamConstraint, LLMSamplingDefaults, ControlNetMode, ControlNetName, ControlNetParams, TextContentPart, ErrorData, ImageProjectParams, ImageOutputFormat, JobStatus, Logger, LogLevel, ProjectParams, ProjectStatus, CreativeWorkflowHostedToolName, StartCreativeWorkflowOptions, StartCreativeWorkflowParams, StartCreativeWorkflowDependency, StartCreativeWorkflowInput, StartCreativeWorkflowStep, StreamCreativeWorkflowEventsOptions, ResumeCreativeWorkflowOptions, ResumeCreativeWorkflowParams, ResumeCreativeWorkflowResult, ReseedCreativeWorkflowOptions, ReseedCreativeWorkflowParams, ReseedCreativeWorkflowResult, ForkWorkflowTemplateBody, ListWorkflowTemplatesOptions, ListWorkflowTemplatesResult, WorkflowTemplate, WorkflowTemplateAuthor, WorkflowTemplateRequestOptions, WorkflowTemplateStability, WorkflowTemplateVisibility, WorkflowTemplateVisibilityFilter, SupernetType, TokenType, ToolCall, ToolCallDelta, ToolCallFunction, ToolChoice, ToolDefinition, ToolExecutionOptions, ToolExecutionProgress, ToolExecutionResult, ToolFunction, ToolHistoryEntry, SogniToolsMode, SocketEventName, SocketEventSubscriptionInput, SocketEventSubscriptionName, SocketEventSubscriptions, SocketEventSubscriptionsUpdatedData, SocketEventSubscriptionUpdate, VideoControlNetName, VideoControlNetParams, VideoFormat, VideoOutputFormat, VideoProjectParams, VideoWorkflowType };
-export { ApiError, ApiKeyAuthManager, ChatStream, ChatToolsApi, CreativeWorkflowsApi, CreativeWorkflowTemplatesApi, CurrentAccount, Job, Project, SogniTools, buildSogniTools, isSogniToolCall, parseCreativeWorkflowSseChunk, parseToolCallArguments };
+export type { AudioFormat, AudioOutputFormat, AudioProjectParams, AvailableModel, ChatCompletionChunk, ChatCompletionParams, ChatCompletionResult, ChatJobStateEvent, ChatMessage, ChatResponseFormat, ChatRunEvent, ChatRunRecord, ChatRunStatus, ChatTokenUsage, StartChatRunParams, StreamChatRunEventsOptions, ContentPart, HostedChatCompletionChoice, HostedChatCompletionMessage, HostedChatCompletionParams, HostedChatCompletionResult, HostedCreativeWorkflowReference, CreativeWorkflowArtifact, CreativeWorkflowEvent, CreativeWorkflowRecord, CreativeWorkflowSseEvent, CreativeWorkflowStatus, ImageUrlContentPart, ListCreativeWorkflowOptions, LLMCostEstimation, LLMJobCost, LLMModelInfo, LLMParamConstraint, LLMSamplingDefaults, ControlNetMode, ControlNetName, ControlNetParams, TextContentPart, ErrorData, ImageProjectParams, ImageOutputFormat, JobStatus, Logger, LogLevel, ProjectParams, ProjectStatus, CreativeWorkflowHostedToolName, StartCreativeWorkflowOptions, StartCreativeWorkflowParams, StartCreativeWorkflowDependency, StartCreativeWorkflowInput, StartCreativeWorkflowStep, StreamCreativeWorkflowEventsOptions, ResumeCreativeWorkflowOptions, ResumeCreativeWorkflowParams, ResumeCreativeWorkflowResult, ReseedCreativeWorkflowOptions, ReseedCreativeWorkflowParams, ReseedCreativeWorkflowResult, ForkWorkflowTemplateBody, ListWorkflowTemplatesOptions, ListWorkflowTemplatesResult, WorkflowTemplate, WorkflowTemplateAuthor, WorkflowTemplateRequestOptions, WorkflowTemplateStability, WorkflowTemplateVisibility, WorkflowTemplateVisibilityFilter, RunRecord, ReplayWriteResult, ReplayRecordSummary, ReplayRequestOptions, ListReplayRecordsOptions, ListReplayRecordsResult, GetReplayRecordResult, SupernetType, TokenType, ToolCall, ToolCallDelta, ToolCallFunction, ToolChoice, ToolDefinition, ToolExecutionOptions, ToolExecutionProgress, ToolExecutionResult, ToolFunction, ToolHistoryEntry, SogniToolsMode, SocketEventName, SocketEventSubscriptionInput, SocketEventSubscriptionName, SocketEventSubscriptions, SocketEventSubscriptionsUpdatedData, SocketEventSubscriptionUpdate, VideoControlNetName, VideoControlNetParams, VideoFormat, VideoOutputFormat, VideoProjectParams, VideoWorkflowType };
+export { ApiError, ApiKeyAuthManager, ChatStream, ChatToolsApi, CreativeWorkflowsApi, CreativeWorkflowTemplatesApi, ReplayApi, CurrentAccount, Job, Project, SogniTools, buildSogniTools, isSogniToolCall, parseCreativeWorkflowSseChunk, parseToolCallArguments };
 export interface SogniClientConfig {
     /**
      * The application ID string. Must be unique, multiple connections with the same ID will be rejected.
@@ -127,6 +129,13 @@ export declare class SogniClient {
      * the client connected.
      */
     workflows: CreativeWorkflowsApi;
+    /**
+     * Replay records (`/v1/replay/records`). Writes one RunRecord per
+     * chat / harness turn and exposes list + get for the replay viewer.
+     * Per-owner isolation is enforced server-side via the SDK auth
+     * identity.
+     */
+    replay: ReplayApi;
     apiClient: ApiClient;
     private constructor();
     get currentAccount(): CurrentAccount;