@elytracms/studio 0.0.56 → 0.0.57

package/dist/lib/ai/tools.d.ts

@@ -1,16 +1,35 @@
 /**
- * The narrow tool set the creation flow's model works against (EC-199).
+ * The narrow tool set the assistant works against (EC-199, reshaped by EC-334).
  *
  * Per the ratified AD, tools execute CLIENT-side against the operations layer with
- * the user's own session — this module only declares their SHAPES (the model-facing
- * planner schema) and the reader interface the studio binds to operations. The engine
- * never gains a write path: `searchDocuments` / `listAssets` are reads that gather the
- * real ids a proposal may reference (a relation id is otherwise structurally
- * impossible — see `buildTargetShape`), and `createDocument` is the terminal action
- * that runs `applyContentWithShape` and yields a reviewable proposal. `updateFields`
- * and `translate` are deliberately NOT here — they are later slices (EC-332 / post-v1).
+ * the user's own session. This module carries the three pieces of that contract:
+ *
+ *  1. {@link chatToolDefinitions} — the SDK-native tool DEFINITIONS the route's
+ *     chat branch declares in `streamText`, deliberately WITHOUT `execute`, so the
+ *     SDK forwards every call to the client (the route stays a zero-data-access
+ *     proxy). Plain `{ description, inputSchema }` objects with zod schemas —
+ *     structurally the SDK's `FunctionTool`, with no SDK import (bundle discipline).
+ *  2. {@link ChatToolReaders} — the operations-backed read interface the studio
+ *     binds client-side (search / list / get). Reads only — the engine never gains
+ *     a write path; apply is a separate, human-gated draft write.
+ *  3. {@link createChatToolExecutor} — the client executor map `useChat`'s
+ *     `onToolCall` dispatches into. Readers pass through; the terminal tools run
+ *     the deterministic engines (`applyContentWithShape` / `translateDocument`)
+ *     through the route's kept `generate` branch and return a COMPACT proposal
+ *     summary as the tool output — the full proposal goes to the review UI via
+ *     `onProposal(toolCallId, …)`, never to the model.
+ *
+ * EC-378 adds `updateFields` as one more definition + one more executor case —
+ * the map's shape leaves that slot open.
+ *
+ * The EC-199 planner enum/schema (`plannerSchema` / `parsePlannerAction`) retired
+ * with the hand-rolled orchestrator (EC-334 slice 2).
  */
-import type { CmsDocument, JsonSchema } from '@elytracms/core/cms-core';
+import { z } from 'zod';
+import type { CmsDocument, CollectionDef, CollectionRegistry, LocaleConfig, ValidateDocumentOptions } from '@elytracms/core/cms-core';
+import type { ComponentManifest } from '@elytracms/core/component-registry';
+import type { ChatProposal } from './chat-state.js';
+import type { AiProvider, RelationCandidates, ResolvedKnowledge } from './types.js';
 /** A document the model may reference as a relation target (from a `searchDocuments` read). */
 export interface DocumentSearchResult {
     id: string;
@@ -22,11 +41,11 @@ export interface AssetSearchResult {
     title?: string;
 }
 /**
- * The client-side, operations-backed readers the orchestrator calls. The studio binds
+ * The client-side, operations-backed readers the executor calls. The studio binds
  * these to the user's authenticated operations client; tests bind an in-memory fake.
  * Reads only — there is no write tool (apply is a separate, human-gated draft write).
  */
-export interface CreateFlowTools {
+export interface ChatToolReaders {
     searchDocuments(input: {
         collection: string;
         query?: string;
@@ -37,41 +56,152 @@ export interface CreateFlowTools {
         limit?: number;
     }): Promise<AssetSearchResult[]>;
     /**
-     * Fetch a full document (values + localized) for the translate flow (EC-332). Optional:
-     * the creation flow never needs it, so a studio that only wires create can omit it.
+     * Fetch a full document (values + localized) — the translate flow and the model's
+     * `getDocument` tool. Optional: a studio that only wires create can omit it.
      */
     getDocument?(input: {
         collection: string;
         id: string;
     }): Promise<CmsDocument | null>;
 }
-/** One planned step the model returns — the discriminated tool/action union. */
-export type PlannerAction = {
-    action: 'searchDocuments';
-    collection: string;
-    query?: string;
-} | {
-    action: 'listAssets';
-    query?: string;
-} | {
-    action: 'createDocument';
-    collection: string;
-    instruction?: string;
-} | {
-    action: 'translateDocument';
-    collection: string;
-    query?: string;
+/** Per-search result cap (protects the wire — results become model context). */
+export declare const DEFAULT_SEARCH_LIMIT = 20;
+/**
+ * One model-facing tool definition for the route's `streamText` call. Structurally
+ * the SDK's `FunctionTool` WITHOUT `execute` (execution is client-side, always) —
+ * typed locally so this module needs no SDK import.
+ */
+export interface ChatToolDefinition {
+    description: string;
+    /** Zod input schema (the AI SDK accepts zod schemas as `inputSchema` directly). */
+    inputSchema: z.ZodType;
+}
+/**
+ * The tool set the native chat branch declares (EC-334). No `execute` on any entry:
+ * the SDK forwards each call to the client, which executes reads against the
+ * operations layer with the user's session and posts the result back; the terminal
+ * tools (`createDocument` / `translateDocument`) run the deterministic engines
+ * client-side and return a compact proposal summary as the tool output. The route
+ * itself never executes anything.
+ *
+ * Collections are NOT enum-leashed here — the route has zero data access, so it has
+ * no catalog; the catalog reaches the model through the request `context` (system
+ * prompt), and every id a proposal references must come from a tool RESULT
+ * (client-validated; `applyContentWithShape` still enum-leashes relation ids).
+ */
+export declare const chatToolDefinitions: {
+    searchDocuments: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            collection: z.ZodString;
+            query: z.ZodOptional<z.ZodString>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+    };
+    listAssets: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            query: z.ZodOptional<z.ZodString>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+    };
+    getDocument: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            collection: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>;
+    };
+    createDocument: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            collection: z.ZodString;
+            instruction: z.ZodString;
+        }, z.core.$strip>;
+    };
+    translateDocument: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            collection: z.ZodString;
+            id: z.ZodString;
+            locale: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+};
+/** One forwarded tool call, as `useChat`'s `onToolCall` receives it. */
+export interface ChatToolCall {
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+}
+/**
+ * A tool execution outcome: an `output` posted back as the tool result, or an
+ * `errorText` posted as an `output-error` part (the model sees the failure and
+ * can react — never a thrown exception into the stream).
+ */
+export type ChatToolOutcome = {
+    ok: true;
+    output: unknown;
 } | {
-    action: 'respond';
-    message: string;
+    ok: false;
+    errorText: string;
 };
-/** The schema name the planner call carries — how a FakeProvider tells plan vs. author. */
-export declare const PLANNER_SCHEMA_NAME = "create_flow_action";
 /**
- * The structured-output schema for ONE planning step. `action` is a closed enum and
- * `collection` is leashed to the known collection ids, so the model can neither invent
- * an action nor target a collection that does not exist.
+ * The per-conversation relation-candidate store: every `searchDocuments` result
+ * is recorded per collection, and `createDocument` may only reference the ids
+ * gathered here (the `applyContentWithShape` enum leash makes a hallucinated id
+ * structurally unrepresentable). Held by the panel per conversation — a new
+ * conversation (EC-380 clear) starts an empty store.
+ */
+export interface ChatCandidateStore {
+    record(collection: string, results: readonly DocumentSearchResult[]): void;
+    /** Candidates for a target collection's relation fields, keyed by field name. */
+    candidatesFor(collection: CollectionDef): RelationCandidates;
+}
+export declare function createChatCandidateStore(): ChatCandidateStore;
+export interface ChatToolExecutorOptions {
+    /** The (route) provider the terminal engines proxy their model calls through. */
+    provider: AiProvider;
+    registry: CollectionRegistry;
+    /** The collections the assistant may target (unknown ids fail loud). */
+    collections: readonly CollectionDef[];
+    /** Operations-backed readers (client-side, user's session). */
+    readers: ChatToolReaders;
+    /** Mint a fresh document id for a new draft (studio: the CMS store's minter). */
+    mintDocumentId: (collectionId: string) => string;
+    /** Per-conversation relation-candidate store (see {@link createChatCandidateStore}). */
+    candidates: ChatCandidateStore;
+    /**
+     * Full proposal sink, keyed by `toolCallId` — the review UI's entry point.
+     * The tool OUTPUT stays a compact summary; the patch never reaches the model.
+     */
+    onProposal: (toolCallId: string, proposal: ChatProposal) => void;
+    /** Current knowledge snapshot (thunk — the body thunk refreshes it per request). */
+    knowledge?: () => ResolvedKnowledge | undefined;
+    /** Component manifests — context for `allow`-leashed richText/blocks fields. */
+    components?: readonly ComponentManifest[];
+    /** Target locale for localized fields. */
+    locale?: string;
+    /** Locale config — required for `translateDocument`. */
+    localeConfig?: LocaleConfig;
+    /** Injected leashes / store for `applyContentWithShape`'s validation. */
+    validateRichTextEmbeds?: ValidateDocumentOptions['validateRichTextEmbeds'];
+    validateComposition?: ValidateDocumentOptions['validateComposition'];
+    store?: ValidateDocumentOptions['store'];
+    /** Max repair attempts inside `applyContentWithShape`. */
+    maxRepairAttempts?: number;
+    /** Per-search result cap (default {@link DEFAULT_SEARCH_LIMIT}). */
+    searchLimit?: number;
+}
+/** The executor `useChat`'s `onToolCall` dispatches into. */
+export interface ChatToolExecutor {
+    execute(call: ChatToolCall): Promise<ChatToolOutcome>;
+}
+/**
+ * Build the client executor map. Every entry validates its input against
+ * {@link chatToolDefinitions}' zod schema (the route validates UIMessages only
+ * structurally — deep input validation is the client's), executes with the
+ * user's session, and returns a JSON-safe outcome. EC-378's `updateFields`
+ * lands as one more case in this dispatch.
  */
-export declare function plannerSchema(collectionIds: readonly string[]): JsonSchema;
-/** Coerce a raw structured-output object into a {@link PlannerAction}; `null` if unusable. */
-export declare function parsePlannerAction(raw: unknown): PlannerAction | null;
+export declare function createChatToolExecutor(options: ChatToolExecutorOptions): ChatToolExecutor;

package/dist/lib/ai/tools.js

@@ -1,74 +1,320 @@
-/** The schema name the planner call carries — how a FakeProvider tells plan vs. author. */
-export const PLANNER_SCHEMA_NAME = 'create_flow_action';
 /**
- * The structured-output schema for ONE planning step. `action` is a closed enum and
- * `collection` is leashed to the known collection ids, so the model can neither invent
- * an action nor target a collection that does not exist.
+ * The narrow tool set the assistant works against (EC-199, reshaped by EC-334).
+ *
+ * Per the ratified AD, tools execute CLIENT-side against the operations layer with
+ * the user's own session. This module carries the three pieces of that contract:
+ *
+ *  1. {@link chatToolDefinitions} — the SDK-native tool DEFINITIONS the route's
+ *     chat branch declares in `streamText`, deliberately WITHOUT `execute`, so the
+ *     SDK forwards every call to the client (the route stays a zero-data-access
+ *     proxy). Plain `{ description, inputSchema }` objects with zod schemas —
+ *     structurally the SDK's `FunctionTool`, with no SDK import (bundle discipline).
+ *  2. {@link ChatToolReaders} — the operations-backed read interface the studio
+ *     binds client-side (search / list / get). Reads only — the engine never gains
+ *     a write path; apply is a separate, human-gated draft write.
+ *  3. {@link createChatToolExecutor} — the client executor map `useChat`'s
+ *     `onToolCall` dispatches into. Readers pass through; the terminal tools run
+ *     the deterministic engines (`applyContentWithShape` / `translateDocument`)
+ *     through the route's kept `generate` branch and return a COMPACT proposal
+ *     summary as the tool output — the full proposal goes to the review UI via
+ *     `onProposal(toolCallId, …)`, never to the model.
+ *
+ * EC-378 adds `updateFields` as one more definition + one more executor case —
+ * the map's shape leaves that slot open.
+ *
+ * The EC-199 planner enum/schema (`plannerSchema` / `parsePlannerAction`) retired
+ * with the hand-rolled orchestrator (EC-334 slice 2).
  */
-export function plannerSchema(collectionIds) {
+import { z } from 'zod';
+import { resolveDocumentTitle } from '@elytracms/core/cms-core';
+import { applyContentWithShape } from './apply-content.js';
+import { translateDocument } from './translate-document.js';
+/** Per-search result cap (protects the wire — results become model context). */
+export const DEFAULT_SEARCH_LIMIT = 20;
+/**
+ * The tool set the native chat branch declares (EC-334). No `execute` on any entry:
+ * the SDK forwards each call to the client, which executes reads against the
+ * operations layer with the user's session and posts the result back; the terminal
+ * tools (`createDocument` / `translateDocument`) run the deterministic engines
+ * client-side and return a compact proposal summary as the tool output. The route
+ * itself never executes anything.
+ *
+ * Collections are NOT enum-leashed here — the route has zero data access, so it has
+ * no catalog; the catalog reaches the model through the request `context` (system
+ * prompt), and every id a proposal references must come from a tool RESULT
+ * (client-validated; `applyContentWithShape` still enum-leashes relation ids).
+ */
+export const chatToolDefinitions = {
+    searchDocuments: {
+        description: 'Search documents in a collection. Use it to find the REAL ids a relation may ' +
+            'reference, or to locate an existing document — never invent an id. Returns ' +
+            '{ id, title } summaries.',
+        inputSchema: z.object({
+            collection: z
+                .string()
+                .describe('Target collection id (from the catalog in the system context).'),
+            query: z.string().optional().describe('Optional search text (title match).'),
+            limit: z.number().int().positive().optional().describe('Max results.'),
+        }),
+    },
+    listAssets: {
+        description: 'List or search assets (images, files). Use it to find REAL asset ids — never ' +
+            'invent one. Returns { id, title } summaries.',
+        inputSchema: z.object({
+            query: z.string().optional().describe('Optional search text.'),
+            limit: z.number().int().positive().optional().describe('Max results.'),
+        }),
+    },
+    getDocument: {
+        description: 'Fetch one full document (values + localized values) by collection and id.',
+        inputSchema: z.object({
+            collection: z.string().describe('Collection id.'),
+            id: z.string().describe('Document id (from a searchDocuments result).'),
+        }),
+    },
+    createDocument: {
+        description: 'Author a NEW document in a collection as a reviewable draft proposal. Terminal ' +
+            'step of a creation request — call it once you have gathered the real ids you ' +
+            'need. Returns a compact proposal summary.',
+        inputSchema: z.object({
+            collection: z.string().describe('Target collection id.'),
+            instruction: z.string().describe('What to write, refining the user request.'),
+        }),
+    },
+    translateDocument: {
+        description: 'Fill the empty locale values of an EXISTING document (search for it first to ' +
+            'get its id). Returns a compact proposal summary.',
+        inputSchema: z.object({
+            collection: z.string().describe('Collection id.'),
+            id: z.string().describe('Document id (from a searchDocuments result).'),
+            locale: z.string().optional().describe('Target locale (defaults to the active one).'),
+        }),
+    },
+};
+export function createChatCandidateStore() {
+    const searched = new Map();
     return {
-        type: 'object',
-        properties: {
-            action: {
-                type: 'string',
-                enum: ['searchDocuments', 'listAssets', 'createDocument', 'translateDocument', 'respond'],
-                description: 'searchDocuments: find real ids for a relation target before creating. ' +
-                    'listAssets: find real asset ids. createDocument: author the document once ' +
-                    'you have what you need. translateDocument: fill the empty locale values of an ' +
-                    'existing document (search for it first to get its id). ' +
-                    'respond: reply without creating anything.',
-            },
-            collection: {
-                type: 'string',
-                ...(collectionIds.length > 0 ? { enum: [...collectionIds] } : {}),
-                description: 'Target collection id (for searchDocuments / createDocument / translateDocument).',
-            },
-            query: {
-                type: 'string',
-                description: 'Optional search text (searchDocuments / listAssets / translateDocument).',
-            },
-            instruction: {
-                type: 'string',
-                description: 'What to write, refining the user request (createDocument).',
-            },
-            message: { type: 'string', description: 'Assistant reply text (respond).' },
+        record(collection, results) {
+            const byId = searched.get(collection) ?? new Map();
+            for (const result of results)
+                byId.set(result.id, result);
+            searched.set(collection, byId);
+        },
+        candidatesFor(collection) {
+            const candidates = {};
+            for (const field of collection.fields) {
+                if (field.type !== 'relation')
+                    continue;
+                const found = searched.get(field.target);
+                if (!found || found.size === 0)
+                    continue;
+                candidates[field.name] = [...found.values()].map((r) => ({ id: r.id, ...(r.title ? { label: r.title } : {}) }));
+            }
+            return candidates;
         },
-        required: ['action'],
-        additionalProperties: false,
     };
 }
-/** Coerce a raw structured-output object into a {@link PlannerAction}; `null` if unusable. */
-export function parsePlannerAction(raw) {
-    if (typeof raw !== 'object' || raw === null)
-        return null;
-    const value = raw;
-    const action = value.action;
-    const str = (k) => typeof value[k] === 'string' && value[k].length > 0 ? value[k] : undefined;
-    switch (action) {
-        case 'searchDocuments': {
-            const collection = str('collection');
-            if (!collection)
-                return null;
-            return { action, collection, ...(str('query') ? { query: str('query') } : {}) };
+function issueSummary(issues) {
+    return issues
+        .slice(0, 5)
+        .map((issue) => issue.message)
+        .join('; ');
+}
+/**
+ * Build the client executor map. Every entry validates its input against
+ * {@link chatToolDefinitions}' zod schema (the route validates UIMessages only
+ * structurally — deep input validation is the client's), executes with the
+ * user's session, and returns a JSON-safe outcome. EC-378's `updateFields`
+ * lands as one more case in this dispatch.
+ */
+export function createChatToolExecutor(options) {
+    const searchLimit = options.searchLimit ?? DEFAULT_SEARCH_LIMIT;
+    function collectionById(id) {
+        return options.collections.find((c) => c.id === id);
+    }
+    async function searchDocuments(input) {
+        if (!collectionById(input.collection)) {
+            return { ok: false, errorText: `Unknown collection "${input.collection}" — use a collection id from the catalog.` };
         }
-        case 'listAssets':
-            return { action, ...(str('query') ? { query: str('query') } : {}) };
-        case 'createDocument': {
-            const collection = str('collection');
-            if (!collection)
-                return null;
-            return { action, collection, ...(str('instruction') ? { instruction: str('instruction') } : {}) };
+        const limit = Math.min(input.limit ?? searchLimit, searchLimit);
+        const results = (await options.readers.searchDocuments({
+            collection: input.collection,
+            ...(input.query ? { query: input.query } : {}),
+            limit,
+        })).slice(0, limit);
+        options.candidates.record(input.collection, results);
+        return { ok: true, output: results };
+    }
+    async function listAssets(input) {
+        const limit = Math.min(input.limit ?? searchLimit, searchLimit);
+        const results = (await options.readers.listAssets({
+            ...(input.query ? { query: input.query } : {}),
+            limit,
+        })).slice(0, limit);
+        return { ok: true, output: results };
+    }
+    async function getDocument(input) {
+        if (!options.readers.getDocument) {
+            return { ok: false, errorText: 'Reading documents is not available here.' };
         }
-        case 'translateDocument': {
-            const collection = str('collection');
-            if (!collection)
-                return null;
-            return { action, collection, ...(str('query') ? { query: str('query') } : {}) };
+        const document = await options.readers.getDocument(input);
+        if (!document) {
+            return { ok: false, errorText: `Document "${input.collection}/${input.id}" was not found.` };
         }
-        case 'respond':
-            return { action, message: str('message') ?? '' };
-        default:
-            return null;
+        return { ok: true, output: document };
     }
+    async function createDocument(toolCallId, input) {
+        const collection = collectionById(input.collection);
+        if (!collection) {
+            return { ok: false, errorText: `Unknown collection "${input.collection}" — use a collection id from the catalog.` };
+        }
+        const documentId = options.mintDocumentId(collection.id);
+        const knowledge = options.knowledge?.();
+        const result = await applyContentWithShape({
+            provider: options.provider,
+            registry: options.registry,
+            collection,
+            documentId,
+            instruction: input.instruction,
+            ...(knowledge ? { knowledge } : {}),
+            ...(options.components ? { components: options.components } : {}),
+            candidates: options.candidates.candidatesFor(collection),
+            ...(options.locale ? { locale: options.locale } : {}),
+            ...(options.validateRichTextEmbeds
+                ? { validateRichTextEmbeds: options.validateRichTextEmbeds }
+                : {}),
+            ...(options.validateComposition ? { validateComposition: options.validateComposition } : {}),
+            ...(options.store ? { store: options.store } : {}),
+            ...(options.maxRepairAttempts !== undefined
+                ? { maxRepairAttempts: options.maxRepairAttempts }
+                : {}),
+        });
+        if (!result.ok) {
+            return {
+                ok: false,
+                errorText: `The drafted ${collection.id} did not pass validation: ${issueSummary(result.issues)}`,
+            };
+        }
+        options.onProposal(toolCallId, {
+            origin: 'create',
+            collection: collection.id,
+            documentId,
+            patch: result.patch,
+            provenance: result.provenance,
+            attempts: result.attempts,
+            issues: result.issues,
+        });
+        // Compact summary only — the full patch goes to the review UI, not the model.
+        return {
+            ok: true,
+            output: {
+                status: 'proposed',
+                collection: collection.id,
+                documentId,
+                title: resolveDocumentTitle(collection, result.patch.values, documentId),
+                note: 'Draft proposal created; the editor reviews and applies it in the studio. Summarize briefly — do not repeat the content.',
+            },
+        };
+    }
+    async function translate(toolCallId, input) {
+        const collection = collectionById(input.collection);
+        if (!collection) {
+            return { ok: false, errorText: `Unknown collection "${input.collection}" — use a collection id from the catalog.` };
+        }
+        if (!options.readers.getDocument || !options.localeConfig) {
+            return { ok: false, errorText: 'Translation is not available here.' };
+        }
+        const document = await options.readers.getDocument({
+            collection: input.collection,
+            id: input.id,
+        });
+        if (!document) {
+            return { ok: false, errorText: `Document "${input.collection}/${input.id}" was not found.` };
+        }
+        const knowledge = options.knowledge?.();
+        const result = await translateDocument({
+            provider: options.provider,
+            collection,
+            document,
+            localeConfig: options.localeConfig,
+            ...(input.locale ? { targetLocales: [input.locale] } : {}),
+            ...(knowledge ? { knowledge } : {}),
+        });
+        if (result.total === 0) {
+            return {
+                ok: true,
+                output: {
+                    status: 'nothing-to-translate',
+                    note: 'Every locale value is already filled — there is nothing to translate.',
+                },
+            };
+        }
+        if (result.translated === 0) {
+            return { ok: false, errorText: 'The translation did not produce any content.' };
+        }
+        options.onProposal(toolCallId, {
+            origin: 'translate',
+            collection: collection.id,
+            documentId: document.id,
+            patch: {
+                collection: collection.id,
+                id: document.id,
+                values: result.document.values,
+                ...(result.document.localized ? { localized: result.document.localized } : {}),
+            },
+            provenance: result.provenance,
+            attempts: 1,
+            issues: [],
+            before: {
+                values: document.values,
+                ...(document.localized ? { localized: document.localized } : {}),
+            },
+        });
+        return {
+            ok: true,
+            output: {
+                status: 'proposed',
+                collection: collection.id,
+                documentId: document.id,
+                translatedUnits: result.translated,
+                note: 'Translation proposal created; the editor reviews and applies it in the studio.',
+            },
+        };
+    }
+    return {
+        async execute(call) {
+            const definition = chatToolDefinitions[call.toolName];
+            if (!definition) {
+                return { ok: false, errorText: `Unknown tool "${call.toolName}".` };
+            }
+            const parsed = definition.inputSchema.safeParse(call.input);
+            if (!parsed.success) {
+                return { ok: false, errorText: `Invalid ${call.toolName} input: ${parsed.error.message}` };
+            }
+            try {
+                switch (call.toolName) {
+                    case 'searchDocuments':
+                        return await searchDocuments(parsed.data);
+                    case 'listAssets':
+                        return await listAssets(parsed.data);
+                    case 'getDocument':
+                        return await getDocument(parsed.data);
+                    case 'createDocument':
+                        return await createDocument(call.toolCallId, parsed.data);
+                    case 'translateDocument':
+                        return await translate(call.toolCallId, parsed.data);
+                    // EC-378: case 'updateFields' lands here (leashed field-update proposals).
+                    default:
+                        return { ok: false, errorText: `Unknown tool "${call.toolName}".` };
+                }
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    errorText: `The ${call.toolName} step failed: ${error instanceof Error ? error.message : 'unknown error'}`,
+                };
+            }
+        },
+    };
 }
 //# sourceMappingURL=tools.js.map