@aphexcms/cms-core 9.7.0 → 9.8.0

package/dist/agent-chat-state.svelte.d.ts

@@ -0,0 +1,38 @@
+export type HistoryMessage = {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    toolCalls?: Array<{
+        id: string;
+        name: string;
+        arguments: Record<string, unknown>;
+    }>;
+    toolCallId?: string;
+};
+export type ToolCall = {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+    status: 'running' | 'complete' | 'error';
+    result?: unknown;
+    error?: string;
+};
+export type Turn = {
+    id: string;
+    role: 'user' | 'assistant';
+    text: string;
+    status: 'complete' | 'streaming' | 'error' | 'stopped';
+    toolCalls: ToolCall[];
+    error?: string;
+    /** Only set on user turns — `history.length` right before this turn was sent, so
+     * `retry()` can roll `history` back to exactly that point rather than guessing an
+     * offset (a turn's server-reported `messages` can add more than 2 entries once tool
+     * calls are involved). */
+    historyIndexBeforeTurn?: number;
+};
+export declare const agentChatState: {
+    turns: Turn[];
+    history: HistoryMessage[];
+    contextSentFor: string | null;
+    lastPromptTokens: number;
+};
+//# sourceMappingURL=agent-chat-state.svelte.d.ts.map

package/dist/agent-chat-state.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-chat-state.svelte.d.ts","sourceRoot":"","sources":["../src/lib/agent-chat-state.svelte.ts"],"names":[],"mappings":"AAkCA,MAAM,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IACpF,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,OAAO,CAAC;IACzC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,GAAG,WAAW,GAAG,OAAO,GAAG,SAAS,CAAC;IACvD,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;8BAG0B;IAC1B,sBAAsB,CAAC,EAAE,MAAM,CAAC;CAChC,CAAC;AA+DF,eAAO,MAAM,cAAc;WAxBR,IAAI,EAAE;aAMJ,cAAc,EAAE;oBAMT,MAAM,GAAG,IAAI;sBAMX,MAAM;CAMgB,CAAC"}

package/dist/agent-chat-state.svelte.js

@@ -0,0 +1,86 @@
+// Module-level state for AgentChat.svelte — deliberately NOT local component state.
+//
+// The assistant panel is mounted inside a Sheet (Sidebar.svelte); bits-ui's Dialog.Content
+// (which Sheet wraps) unmounts its children when closed, so a plain `$state` declared inside
+// AgentChat.svelte gets destroyed and recreated every time the panel is closed and reopened —
+// the conversation would vanish even without navigating away or reloading. A module-level
+// singleton survives that remount (and client-side navigation, since it's the same JS module
+// instance) — same pattern as `activeTabState` (apps/studio/src/lib/stores/activeTab.svelte.ts).
+//
+// Also mirrored to localStorage so it survives a hard reload too — still just this one
+// browser tab's convenience cache, not real conversation persistence (a DB-backed, multi-
+// conversation, cross-device history is a separate, bigger feature, deliberately not built
+// yet — see the conversation that led here). Wrapped in try/catch throughout: private
+// browsing / a full storage quota must never break the chat, just silently skip persisting.
+const STORAGE_KEY = 'aphex:agent-chat-state:v1';
+function loadPersisted() {
+    if (typeof localStorage === 'undefined')
+        return null;
+    try {
+        const raw = localStorage.getItem(STORAGE_KEY);
+        return raw ? JSON.parse(raw) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function createAgentChatState() {
+    const persisted = loadPersisted();
+    let turns = $state(persisted?.turns ?? []);
+    let history = $state(persisted?.history ?? []);
+    let contextSentFor = $state(persisted?.contextSentFor ?? null);
+    // The most recent `usage.promptTokens` reported by the model — since this endpoint
+    // resends the full conversation on every call, this is effectively "how big the
+    // conversation currently is," used to warn before it gets unwieldy (or expensive).
+    let lastPromptTokens = $state(persisted?.lastPromptTokens ?? 0);
+    // A live turn mid-stream shouldn't be persisted as if it finished — reload would show a
+    // permanently "streaming" bubble with a spinner that will never resolve. Reloading the
+    // page always means the in-flight request is gone, so mark it stopped instead.
+    for (const turn of turns) {
+        if (turn.status === 'streaming')
+            turn.status = 'stopped';
+    }
+    if (typeof localStorage !== 'undefined') {
+        $effect.root(() => {
+            $effect(() => {
+                // Reading `turns`/`history`/`contextSentFor` here is what makes this effect
+                // re-run on every mutation (including in-place `.push()`, via `$state`'s deep
+                // reactivity) — not just on reassignment.
+                const snapshot = { turns, history, contextSentFor, lastPromptTokens };
+                try {
+                    localStorage.setItem(STORAGE_KEY, JSON.stringify(snapshot));
+                }
+                catch {
+                    // Quota exceeded / private browsing — best-effort only, drop it.
+                }
+            });
+        });
+    }
+    return {
+        get turns() {
+            return turns;
+        },
+        set turns(value) {
+            turns = value;
+        },
+        get history() {
+            return history;
+        },
+        set history(value) {
+            history = value;
+        },
+        get contextSentFor() {
+            return contextSentFor;
+        },
+        set contextSentFor(value) {
+            contextSentFor = value;
+        },
+        get lastPromptTokens() {
+            return lastPromptTokens;
+        },
+        set lastPromptTokens(value) {
+            lastPromptTokens = value;
+        }
+    };
+}
+export const agentChatState = createAgentChatState();

package/dist/ai/content-workspace-tools.d.ts

@@ -0,0 +1,3 @@
+import type { ContentAgentTool } from '../mcp/tools.js';
+export declare const contentWorkspaceTools: ContentAgentTool[];
+//# sourceMappingURL=content-workspace-tools.d.ts.map

package/dist/ai/content-workspace-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-workspace-tools.d.ts","sourceRoot":"","sources":["../../src/lib/ai/content-workspace-tools.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAQrD,eAAO,MAAM,qBAAqB,EAAE,gBAAgB,EA8BnD,CAAC"}

package/dist/ai/content-workspace-tools.js

@@ -0,0 +1,50 @@
+// ai/content-workspace-tools.ts
+//
+// The two `execution: 'workspace'` tools: `content_patch_fields` (buffer a shallow-merge
+// patch onto the document currently open in an editor tab) and `content_save_draft`
+// (flush the buffered patch(es) as one CAS-guarded save). Live outside `mcp/tools.ts` on
+// purpose — these aren't MCP-servable (an MCP client has no browser tab holding a live
+// draft), so they only ever reach a caller through `resolveAgentTools`'s `documentContext`
+// gate (`mcp/tools.ts`).
+//
+// `execute` on both is unreachable in practice: `run-agent-turn.ts`'s per-round tool loop
+// partitions calls by `definition.execution` and never calls `.execute` for a `'workspace'`
+// tool — it pauses the turn instead (see `types/agent-stream.ts`'s `done` event doc) and the
+// *client* resolves the call against a live `DocumentWorkspace`. These bodies exist only to
+// satisfy `ContentAgentTool`'s shape; don't "clean them up" into something callable without
+// also removing the pause branch in `run-agent-turn.ts`, or a workspace tool would silently
+// execute server-side against no live draft at all.
+import { z } from 'zod';
+const unreachable = (name) => Promise.resolve({
+    success: false,
+    error: `${name} must be resolved client-side against a live DocumentWorkspace; the server should never execute it directly.`
+});
+export const contentWorkspaceTools = [
+    {
+        definition: {
+            name: 'content_patch_fields',
+            description: 'Patch scalar/reference/asset fields on the document currently open in the editor. ' +
+                'Buffered in-memory only — nothing is persisted until content_save_draft is called. ' +
+                'Fields not mentioned are left unchanged.',
+            mutates: true,
+            requiredCapabilities: ['document.update'],
+            execution: 'workspace',
+            inputSchema: z.object({
+                fields: z.record(z.string(), z.unknown()).describe('Top-level field name -> new value.')
+            })
+        },
+        execute: () => unreachable('content_patch_fields')
+    },
+    {
+        definition: {
+            name: 'content_save_draft',
+            description: 'Persist the field patch(es) applied via content_patch_fields to the open document as ' +
+                'one draft save, guarded against concurrent edits. Does not publish.',
+            mutates: true,
+            requiredCapabilities: ['document.update'],
+            execution: 'workspace',
+            inputSchema: z.object({})
+        },
+        execute: () => unreachable('content_save_draft')
+    }
+];

package/dist/ai/default-system-prompt.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_AGENT_SYSTEM_PROMPT = "You are the in-admin content assistant for this CMS. You can read and edit content through the tools available to you \u2014 call `describe_cms` first if you don't already know what content types, fields, and tools exist in this session; never guess at a schema's shape.\n\nGuidelines:\n- Prefer drafts: create or edit content as a draft. Only call `publish_document` when the user has explicitly asked you to publish \u2014 writing or updating something is not itself a request to publish it.\n- If `content_patch_fields`/`content_save_draft` are available, a document is currently open in the admin editor \u2014 use those two tools (not `update_document`) for any edit to that document, so the change appears live in the editor instead of only in the database.\n- Before a broad or hard-to-reverse change (bulk edits, unpublishing, overwriting existing content), briefly say what you're about to do rather than doing it silently.\n- Only reference fields, collections, and tools that `describe_cms`/`get_schema` actually showed you \u2014 never invent one.\n- If a tool call fails or is forbidden, say why rather than retrying blindly or working around it.\n- Keep responses concise \u2014 don't restate what a tool result already showed.";
+//# sourceMappingURL=default-system-prompt.d.ts.map

package/dist/ai/default-system-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-system-prompt.d.ts","sourceRoot":"","sources":["../../src/lib/ai/default-system-prompt.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,2BAA2B,8tCAQoC,CAAC"}

package/dist/ai/default-system-prompt.js

@@ -0,0 +1,15 @@
+// The in-admin agent's default system prompt. Overridable per-instance via
+// `createCMSConfig({ agentSystemPrompt: '...' })` (see types/config.ts) — an agency
+// deploying this CMS for a client may want different tone/guardrails than another. Kept
+// short and behavioral rather than descriptive: the tool list, schema, and capabilities are
+// already self-describing via the `describe_cms` tool, so this only needs to say things a
+// tool description can't — when to hold back, not what exists.
+export const DEFAULT_AGENT_SYSTEM_PROMPT = `You are the in-admin content assistant for this CMS. You can read and edit content through the tools available to you — call \`describe_cms\` first if you don't already know what content types, fields, and tools exist in this session; never guess at a schema's shape.
+
+Guidelines:
+- Prefer drafts: create or edit content as a draft. Only call \`publish_document\` when the user has explicitly asked you to publish — writing or updating something is not itself a request to publish it.
+- If \`content_patch_fields\`/\`content_save_draft\` are available, a document is currently open in the admin editor — use those two tools (not \`update_document\`) for any edit to that document, so the change appears live in the editor instead of only in the database.
+- Before a broad or hard-to-reverse change (bulk edits, unpublishing, overwriting existing content), briefly say what you're about to do rather than doing it silently.
+- Only reference fields, collections, and tools that \`describe_cms\`/\`get_schema\` actually showed you — never invent one.
+- If a tool call fails or is forbidden, say why rather than retrying blindly or working around it.
+- Keep responses concise — don't restate what a tool result already showed.`;

package/dist/ai/index.d.ts

@@ -0,0 +1,2 @@
+export * from './interfaces/ai-provider.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ai/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/ai/index.ts"],"names":[],"mappings":"AAIA,cAAc,0BAA0B,CAAC"}

package/dist/ai/index.js

@@ -0,0 +1,4 @@
+// Aphex CMS AI Layer
+// Ports and adapters for the in-admin agent's model backend
+// Interfaces
+export * from './interfaces/ai-provider.js';

package/dist/ai/interfaces/ai-provider.d.ts

@@ -0,0 +1,67 @@
+/** One message in a conversation. `tool` messages carry the result of a prior `toolCallId`. */
+export interface AIMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    /** Present on an assistant message that requested one or more tool calls. */
+    toolCalls?: AIToolCall[];
+    /** Present on a `tool` role message — which prior call this is the result of. */
+    toolCallId?: string;
+}
+/** A single tool invocation the model requested. */
+export interface AIToolCall {
+    id: string;
+    name: string;
+    /** Parsed JSON arguments the model produced — already validated against the tool's zod schema by the caller before execution. */
+    arguments: Record<string, unknown>;
+}
+/**
+ * A tool definition adapted to the provider's function-calling format. The
+ * adapter owns converting `AgentToolDefinition.inputSchema` (zod) into this
+ * shape — cms-core stays schema-library-agnostic on the wire, only zod
+ * internally.
+ */
+export interface AIToolSpec {
+    name: string;
+    description: string;
+    /** JSON Schema describing the arguments object. */
+    parameters: Record<string, unknown>;
+}
+export interface AIChatRequest {
+    /** Provider-specific model identifier, e.g. `anthropic/claude-sonnet-4.5` (OpenRouter) or `claude-sonnet-4-5` (Anthropic direct). */
+    model: string;
+    messages: AIMessage[];
+    tools?: AIToolSpec[];
+    /** Optional cap; adapters should pass their provider's equivalent through unchanged when omitted. */
+    maxTokens?: number;
+    /** Aborts the in-flight request — cancellation propagates from the browser tab through the runtime to here. */
+    signal?: AbortSignal;
+}
+/**
+ * One item in a streamed response. The runtime layer (apps/studio, not
+ * cms-core) maps this onto whatever wire format it sends the browser
+ * (SSE/NDJSON) — this is the provider-boundary shape, not the browser-facing
+ * one, though the two are intentionally close.
+ */
+export type AIStreamEvent = {
+    type: 'text';
+    delta: string;
+} | {
+    type: 'toolCall';
+    toolCall: AIToolCall;
+} | {
+    type: 'usage';
+    promptTokens: number;
+    completionTokens: number;
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'done';
+    finishReason: 'stop' | 'tool_calls' | 'length' | 'error';
+};
+export interface AIProviderAdapter {
+    readonly name: string;
+    /** Stream a chat completion, yielding events as the model produces them. */
+    chatStream(request: AIChatRequest): AsyncIterable<AIStreamEvent>;
+}
+//# sourceMappingURL=ai-provider.d.ts.map

package/dist/ai/interfaces/ai-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-provider.d.ts","sourceRoot":"","sources":["../../../src/lib/ai/interfaces/ai-provider.ts"],"names":[],"mappings":"AAgBA,+FAA+F;AAC/F,MAAM,WAAW,SAAS;IACzB,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,SAAS,CAAC,EAAE,UAAU,EAAE,CAAC;IACzB,iFAAiF;IACjF,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,oDAAoD;AACpD,MAAM,WAAW,UAAU;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,iIAAiI;IACjI,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,aAAa;IAC7B,qIAAqI;IACrI,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;IACrB,qGAAqG;IACrG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+GAA+G;IAC/G,MAAM,CAAC,EAAE,WAAW,CAAC;CACrB;AAED;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GACtB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,UAAU,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAE,GACjE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,GAAG,YAAY,GAAG,QAAQ,GAAG,OAAO,CAAA;CAAE,CAAC;AAE9E,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4EAA4E;IAC5E,UAAU,CAAC,OAAO,EAAE,aAAa,GAAG,aAAa,CAAC,aAAa,CAAC,CAAC;CACjE"}

package/dist/ai/interfaces/ai-provider.js

@@ -0,0 +1,16 @@
+// ai/interfaces/ai-provider.ts
+//
+// Ports & adapters for the in-admin agent's model backend — same shape as
+// EmailAdapter (see ../../email/interfaces/email.ts): cms-core owns the
+// provider-neutral contract only; concrete provider clients (credentials,
+// wire format, streaming parse) live in separate packages the app wires in
+// via `createCMSConfig({ aiProvider: ... })`. Exactly one active instance-wide,
+// same as database/storage/email — not a plugin, since a CMS install picks
+// one model backend, not a composable set of them.
+//
+// Two adapters cover four providers: OpenAI, OpenRouter, and Ollama all speak
+// the same OpenAI-compatible chat-completions + function-calling wire format
+// (they differ only in base URL and auth), so one adapter handles all three;
+// Anthropic's Messages API has a genuinely different shape (`tool_use` content
+// blocks vs OpenAI's `tool_calls`) and gets its own.
+export {};

package/dist/ai/run-agent-turn.d.ts

@@ -0,0 +1,29 @@
+import type { AIProviderAdapter, AIMessage } from './interfaces/ai-provider.js';
+import type { AgentStreamEvent } from '../types/agent-stream.js';
+import type { ContentAgentTool } from '../mcp/tools.js';
+import type { AgentToolExecutionContext } from '../types/agent-tools.js';
+export interface RunAgentTurnOptions {
+    aiProvider: AIProviderAdapter;
+    model: string;
+    messages: AIMessage[];
+    /** The caller's resolved tool list — see `resolveAgentTools` in `mcp/tools.ts`. */
+    tools: ContentAgentTool[];
+    toolContext: AgentToolExecutionContext;
+    /** Prepended ahead of `messages` on every model call within this turn, but never spliced
+     * into `messages` itself — it must stay out of the `done` event's `messages` (what the
+     * client persists and replays next turn), or a stale copy would get resent forever and an
+     * app-level prompt change would never reach an already-open conversation. */
+    systemPrompt?: string;
+    maxTokens?: number;
+    /** Safety cap on tool-calling round trips before the turn is force-stopped as an error. */
+    maxToolRoundtrips?: number;
+    signal?: AbortSignal;
+}
+/**
+ * Streams one agent turn: sends `messages` to the model, executes any tool calls it
+ * requests against `tools`, feeds the results back as `tool` messages, and repeats until
+ * the model stops calling tools (or `maxToolRoundtrips` is hit — surfaced as an error
+ * rather than looping forever against a model that won't stop calling tools).
+ */
+export declare function runAgentTurn(opts: RunAgentTurnOptions): AsyncIterable<AgentStreamEvent>;
+//# sourceMappingURL=run-agent-turn.d.ts.map

package/dist/ai/run-agent-turn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-agent-turn.d.ts","sourceRoot":"","sources":["../../src/lib/ai/run-agent-turn.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACX,iBAAiB,EACjB,SAAS,EAGT,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAGtE,MAAM,WAAW,mBAAmB;IACnC,UAAU,EAAE,iBAAiB,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,mFAAmF;IACnF,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,WAAW,EAAE,yBAAyB,CAAC;IACvC;;;iFAG6E;IAC7E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2FAA2F;IAC3F,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,MAAM,CAAC,EAAE,WAAW,CAAC;CACrB;AAYD;;;;;GAKG;AACH,wBAAuB,YAAY,CAAC,IAAI,EAAE,mBAAmB,GAAG,aAAa,CAAC,gBAAgB,CAAC,CAuJ9F"}

package/dist/ai/run-agent-turn.js

@@ -0,0 +1,166 @@
+// ai/run-agent-turn.ts
+//
+// The tool-calling loop that drives one agent turn to completion — the "runtime" half of sitting on top of the
+// `AIProviderAdapter` port and the `ContentAgentTool` list `resolveAgentTools` (mcp/tools.ts)
+// already resolves for MCP. Transport-agnostic: this function has no knowledge of HTTP/SSE —
+// a route handler consumes the `AgentStreamEvent`s it yields and maps them onto the wire.
+import { z } from 'zod';
+import { hasCapability } from '../types/capabilities.js';
+const DEFAULT_MAX_TOOL_ROUNDTRIPS = 8;
+function toToolSpec(tool) {
+    return {
+        name: tool.definition.name,
+        description: tool.definition.description,
+        parameters: z.toJSONSchema(tool.definition.inputSchema)
+    };
+}
+/**
+ * Streams one agent turn: sends `messages` to the model, executes any tool calls it
+ * requests against `tools`, feeds the results back as `tool` messages, and repeats until
+ * the model stops calling tools (or `maxToolRoundtrips` is hit — surfaced as an error
+ * rather than looping forever against a model that won't stop calling tools).
+ */
+export async function* runAgentTurn(opts) {
+    const messages = [...opts.messages];
+    const systemMessage = opts.systemPrompt
+        ? { role: 'system', content: opts.systemPrompt }
+        : null;
+    const toolsByName = new Map(opts.tools.map((t) => [t.definition.name, t]));
+    const toolSpecs = opts.tools.map(toToolSpec);
+    const maxRoundtrips = opts.maxToolRoundtrips ?? DEFAULT_MAX_TOOL_ROUNDTRIPS;
+    let roundtrips = 0;
+    for (;;) {
+        let assistantText = '';
+        const pendingToolCalls = [];
+        let finishReason = 'stop';
+        let erroredOut = false;
+        for await (const event of opts.aiProvider.chatStream({
+            model: opts.model,
+            messages: systemMessage ? [systemMessage, ...messages] : messages,
+            tools: toolSpecs,
+            maxTokens: opts.maxTokens,
+            signal: opts.signal
+        })) {
+            switch (event.type) {
+                case 'text':
+                    assistantText += event.delta;
+                    yield event;
+                    break;
+                case 'toolCall':
+                    pendingToolCalls.push(event.toolCall);
+                    yield {
+                        type: 'toolCall',
+                        toolCallId: event.toolCall.id,
+                        name: event.toolCall.name,
+                        arguments: event.toolCall.arguments
+                    };
+                    break;
+                case 'usage':
+                    yield event;
+                    break;
+                case 'error':
+                    yield event;
+                    erroredOut = true;
+                    break;
+                case 'done':
+                    finishReason = event.finishReason;
+                    break;
+            }
+        }
+        if (erroredOut) {
+            if (assistantText)
+                messages.push({ role: 'assistant', content: assistantText });
+            yield { type: 'done', finishReason: 'error', messages };
+            return;
+        }
+        if (finishReason !== 'tool_calls' || pendingToolCalls.length === 0) {
+            // Unlike the tool-calling branch below, nothing else pushes this round's assistant
+            // reply onto `messages` — this is the terminal round, so it must happen here or the
+            // model's final answer would be silently missing from the conversation `messages`
+            // hands back for the next turn to replay.
+            if (assistantText)
+                messages.push({ role: 'assistant', content: assistantText });
+            yield { type: 'done', finishReason, messages };
+            return;
+        }
+        if (++roundtrips > maxRoundtrips) {
+            yield { type: 'error', message: `Stopped after ${maxRoundtrips} tool-calling round trips.` };
+            yield { type: 'done', finishReason: 'error', messages };
+            return;
+        }
+        messages.push({ role: 'assistant', content: assistantText, toolCalls: pendingToolCalls });
+        // `execution: 'workspace'` tools touch a live, possibly-unsaved editor draft that only
+        // exists in the browser — this server-side loop can't run them. Every other call in the
+        // round still executes normally below; the workspace calls are set aside and, once the
+        // round finishes, pause the turn instead of looping — the caller resolves them locally
+        // and resumes with a fresh request (see `types/agent-stream.ts`'s `done` event doc).
+        const workspaceCalls = [];
+        const executableCalls = [];
+        for (const call of pendingToolCalls) {
+            const tool = toolsByName.get(call.name);
+            (tool?.definition.execution === 'workspace' ? workspaceCalls : executableCalls).push(call);
+        }
+        for (const call of executableCalls) {
+            const tool = toolsByName.get(call.name);
+            let success;
+            let data;
+            let error;
+            if (!tool) {
+                success = false;
+                error = `Unknown tool: ${call.name}`;
+            }
+            else {
+                // Defense in depth: `tools` is expected to already be filtered to this caller's
+                // capabilities (see `resolveAgentTools`), but a tool must reject direct invocation
+                // too — never rely on the advertisement filter alone (AgentToolDefinition's own
+                // doc comment on `requiredCapabilities` is explicit about this).
+                const requiredCaps = tool.definition.requiredCapabilities ?? [];
+                const auth = opts.toolContext.context.auth;
+                const authorized = requiredCaps.length === 0 ||
+                    (auth != null && requiredCaps.every((c) => hasCapability(auth, c)));
+                if (!authorized) {
+                    success = false;
+                    error = `Forbidden: requires ${requiredCaps.join(', ')}`;
+                }
+                else {
+                    const parsed = tool.definition.inputSchema.safeParse(call.arguments);
+                    if (!parsed.success) {
+                        success = false;
+                        error = `Invalid arguments: ${parsed.error.message}`;
+                    }
+                    else {
+                        try {
+                            const result = await tool.execute(parsed.data, opts.toolContext);
+                            success = result.success;
+                            data = result.success ? result.data : undefined;
+                            error = result.success ? undefined : result.error;
+                        }
+                        catch (err) {
+                            success = false;
+                            error = err instanceof Error ? err.message : String(err);
+                        }
+                    }
+                }
+            }
+            yield { type: 'toolResult', toolCallId: call.id, name: call.name, success, data, error };
+            messages.push({
+                role: 'tool',
+                toolCallId: call.id,
+                content: JSON.stringify(success ? (data ?? null) : { error })
+            });
+        }
+        if (workspaceCalls.length > 0) {
+            yield {
+                type: 'done',
+                finishReason: 'awaiting_workspace_tool',
+                messages,
+                pendingWorkspaceCalls: workspaceCalls.map((c) => ({
+                    toolCallId: c.id,
+                    name: c.name,
+                    arguments: c.arguments
+                }))
+            };
+            return;
+        }
+    }
+}

package/dist/api/agent-chat.d.ts

@@ -0,0 +1,27 @@
+import type { ApiResponse } from './types.js';
+import type { AgentChatRequest } from './schemas/agent-chat.js';
+import type { RecordWorkspaceOperationRequest } from './schemas/agent-operations.js';
+import type { AgentStreamEvent } from '../types/agent-stream.js';
+/**
+ * Streams one leg of an agent turn. Not built on `apiClient` — that always `await`s and parses
+ * a JSON body, which is structurally incompatible with a chunked SSE response; this is the one
+ * agent-chat call that needs the raw `fetch` + `ReadableStream`. `signal` is caller-supplied
+ * (not `apiClient`'s own internal 10s timeout) so the chat panel's Stop button can abort
+ * mid-stream regardless of how long a turn runs.
+ *
+ * A turn that pauses for a workspace tool (`finishReason: 'awaiting_workspace_tool'`) ends this
+ * generator normally — resolving the pause and resuming is the caller's job (`AgentChat.svelte`
+ * re-calls this with the same `changeSetId` echoed back), not something this function loops on
+ * itself.
+ */
+export declare function streamAgentChat(body: AgentChatRequest, signal?: AbortSignal): AsyncGenerator<AgentStreamEvent>;
+/**
+ * Records an audit row for a workspace-bridge tool (`content_patch_fields`/`content_save_draft`)
+ * the client resolved locally against a live `DocumentWorkspace` — see
+ * `server/api/routes/agent-chat.ts`'s `POST /operations`. Plain JSON request/response, so unlike
+ * `streamAgentChat` above, this one goes through the shared `apiClient`.
+ */
+export declare function recordWorkspaceOperation(body: RecordWorkspaceOperationRequest): Promise<ApiResponse<{
+    success: true;
+}>>;
+//# sourceMappingURL=agent-chat.d.ts.map

package/dist/api/agent-chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-chat.d.ts","sourceRoot":"","sources":["../../src/lib/api/agent-chat.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,4BAA4B,CAAC;AAClF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAY9D;;;;;;;;;;;GAWG;AACH,wBAAuB,eAAe,CACrC,IAAI,EAAE,gBAAgB,EACtB,MAAM,CAAC,EAAE,WAAW,GAClB,cAAc,CAAC,gBAAgB,CAAC,CA8BlC;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACvC,IAAI,EAAE,+BAA+B,GACnC,OAAO,CAAC,WAAW,CAAC;IAAE,OAAO,EAAE,IAAI,CAAA;CAAE,CAAC,CAAC,CAEzC"}

package/dist/api/agent-chat.js

@@ -0,0 +1,64 @@
+// Agent chat API client — the two HTTP calls AgentChat.svelte's send() loop makes, pulled out
+// of the component per the same convention as api/documents.ts/api/assets.ts.
+import { apiClient } from './client.js';
+function parseSSEFrame(frame) {
+    const payload = frame
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith('data:'))
+        .map((line) => line.slice(5).trimStart())
+        .join('\n');
+    if (!payload)
+        return null;
+    return JSON.parse(payload);
+}
+/**
+ * Streams one leg of an agent turn. Not built on `apiClient` — that always `await`s and parses
+ * a JSON body, which is structurally incompatible with a chunked SSE response; this is the one
+ * agent-chat call that needs the raw `fetch` + `ReadableStream`. `signal` is caller-supplied
+ * (not `apiClient`'s own internal 10s timeout) so the chat panel's Stop button can abort
+ * mid-stream regardless of how long a turn runs.
+ *
+ * A turn that pauses for a workspace tool (`finishReason: 'awaiting_workspace_tool'`) ends this
+ * generator normally — resolving the pause and resuming is the caller's job (`AgentChat.svelte`
+ * re-calls this with the same `changeSetId` echoed back), not something this function loops on
+ * itself.
+ */
+export async function* streamAgentChat(body, signal) {
+    const response = await fetch('/api/agent/chat', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+        signal
+    });
+    if (!response.ok || !response.body) {
+        const errorBody = await response.json().catch(() => null);
+        throw new Error(errorBody?.error ?? `Request failed (${response.status})`);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    for (;;) {
+        const { done, value } = await reader.read();
+        buffer += decoder.decode(value, { stream: !done });
+        const frames = buffer.split(/\r?\n\r?\n/);
+        buffer = frames.pop() ?? '';
+        if (done && buffer.trim())
+            frames.push(buffer);
+        for (const frame of frames) {
+            const event = parseSSEFrame(frame);
+            if (event)
+                yield event;
+        }
+        if (done)
+            break;
+    }
+}
+/**
+ * Records an audit row for a workspace-bridge tool (`content_patch_fields`/`content_save_draft`)
+ * the client resolved locally against a live `DocumentWorkspace` — see
+ * `server/api/routes/agent-chat.ts`'s `POST /operations`. Plain JSON request/response, so unlike
+ * `streamAgentChat` above, this one goes through the shared `apiClient`.
+ */
+export function recordWorkspaceOperation(body) {
+    return apiClient.post('/agent/operations', body);
+}