@contractspec/module.ai-chat 4.3.17 → 4.3.18

package/dist/node/presentation/hooks/index.js

@@ -1,685 +1,40 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/presentation/hooks/index.ts
-import { useCompletion } from "@ai-sdk/react";
-
-// src/presentation/hooks/useChat.tsx
-import {
-  createProvider
-} from "@contractspec/lib.ai-providers";
-import { tool as tool4 } from "ai";
-import * as React from "react";
-import { z as z4 } from "zod";
-
-// src/core/chat-service.ts
-import { generateText, streamText } from "ai";
-import { compilePlannerPrompt } from "@contractspec/lib.surface-runtime/runtime/planner-prompt";
-
-// src/core/agent-tools-adapter.ts
-import { tool } from "ai";
-import { z } from "zod";
-function getInputSchema(_schema) {
-  return z.object({}).passthrough();
-}
-function agentToolConfigsToToolSet(configs, handlers) {
-  const result = {};
-  for (const config of configs) {
-    const handler = handlers?.[config.name];
-    const inputSchema = getInputSchema(config.schema);
-    result[config.name] = tool({
-      description: config.description ?? config.name,
-      inputSchema,
-      execute: async (input) => {
-        if (!handler) {
-          return {
-            status: "unimplemented",
-            message: "Wire handler in host",
-            toolName: config.name
-          };
-        }
-        try {
-          const output = await Promise.resolve(handler(input));
-          return typeof output === "string" ? output : output;
-        } catch (err) {
-          return {
-            status: "error",
-            error: err instanceof Error ? err.message : String(err),
-            toolName: config.name
-          };
-        }
-      }
-    });
-  }
-  return result;
-}
-
-// src/core/contracts-context.ts
-function buildContractsContextPrompt(config) {
-  const parts = [];
-  if (!config.agentSpecs?.length && !config.dataViewSpecs?.length && !config.formSpecs?.length && !config.presentationSpecs?.length && !config.operationRefs?.length) {
-    return "";
-  }
-  parts.push(`
-
-## Available resources`);
-  if (config.agentSpecs?.length) {
-    parts.push(`
-### Agent tools`);
-    for (const agent of config.agentSpecs) {
-      const toolNames = agent.tools?.map((t) => t.name).join(", ") ?? "none";
-      parts.push(`- **${agent.key}**: tools: ${toolNames}`);
-    }
-  }
-  if (config.dataViewSpecs?.length) {
-    parts.push(`
-### Data views`);
-    for (const dv of config.dataViewSpecs) {
-      parts.push(`- **${dv.key}**: ${dv.meta.title ?? dv.key}`);
-    }
-  }
-  if (config.formSpecs?.length) {
-    parts.push(`
-### Forms`);
-    for (const form of config.formSpecs) {
-      parts.push(`- **${form.key}**: ${form.meta.title ?? form.key}`);
-    }
-  }
-  if (config.presentationSpecs?.length) {
-    parts.push(`
-### Presentations`);
-    for (const pres of config.presentationSpecs) {
-      parts.push(`- **${pres.key}**: ${pres.meta.title ?? pres.key} (targets: ${pres.targets?.join(", ") ?? "react"})`);
-    }
-  }
-  if (config.operationRefs?.length) {
-    parts.push(`
-### Operations`);
-    for (const op of config.operationRefs) {
-      parts.push(`- **${op.key}@${op.version}**`);
-    }
-  }
-  parts.push(`
-Use the available tools to invoke operations, query data views, or propose surface changes when appropriate.`);
-  return parts.join(`
-`);
-}
-
-// src/core/conversation-store.ts
-function generateId(prefix) {
-  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
-}
-
-class InMemoryConversationStore {
-  conversations = new Map;
-  async get(conversationId) {
-    return this.conversations.get(conversationId) ?? null;
-  }
-  async create(conversation) {
-    const now = new Date;
-    const fullConversation = {
-      ...conversation,
-      id: generateId("conv"),
-      createdAt: now,
-      updatedAt: now
-    };
-    this.conversations.set(fullConversation.id, fullConversation);
-    return fullConversation;
-  }
-  async update(conversationId, updates) {
-    const conversation = this.conversations.get(conversationId);
-    if (!conversation)
-      return null;
-    const updated = {
-      ...conversation,
-      ...updates,
-      updatedAt: new Date
-    };
-    this.conversations.set(conversationId, updated);
-    return updated;
-  }
-  async appendMessage(conversationId, message) {
-    const conversation = this.conversations.get(conversationId);
-    if (!conversation) {
-      throw new Error(`Conversation ${conversationId} not found`);
-    }
-    const now = new Date;
-    const fullMessage = {
-      ...message,
-      id: generateId("msg"),
-      conversationId,
-      createdAt: now,
-      updatedAt: now
-    };
-    conversation.messages.push(fullMessage);
-    conversation.updatedAt = now;
-    return fullMessage;
-  }
-  async updateMessage(conversationId, messageId, updates) {
-    const conversation = this.conversations.get(conversationId);
-    if (!conversation)
-      return null;
-    const messageIndex = conversation.messages.findIndex((m) => m.id === messageId);
-    if (messageIndex === -1)
-      return null;
-    const message = conversation.messages[messageIndex];
-    if (!message)
-      return null;
-    const updated = {
-      ...message,
-      ...updates,
-      updatedAt: new Date
-    };
-    conversation.messages[messageIndex] = updated;
-    conversation.updatedAt = new Date;
-    return updated;
-  }
-  async delete(conversationId) {
-    return this.conversations.delete(conversationId);
-  }
-  async list(options) {
-    let results = Array.from(this.conversations.values());
-    if (options?.status) {
-      results = results.filter((c) => c.status === options.status);
-    }
-    if (options?.projectId) {
-      results = results.filter((c) => c.projectId === options.projectId);
-    }
-    if (options?.tags && options.tags.length > 0) {
-      const tagSet = new Set(options.tags);
-      results = results.filter((c) => c.tags && c.tags.some((t) => tagSet.has(t)));
-    }
-    results.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
-    const offset = options?.offset ?? 0;
-    const limit = options?.limit ?? 100;
-    return results.slice(offset, offset + limit);
-  }
-  async fork(conversationId, upToMessageId) {
-    const source = this.conversations.get(conversationId);
-    if (!source) {
-      throw new Error(`Conversation ${conversationId} not found`);
-    }
-    let messagesToCopy = source.messages;
-    if (upToMessageId) {
-      const idx = source.messages.findIndex((m) => m.id === upToMessageId);
-      if (idx === -1) {
-        throw new Error(`Message ${upToMessageId} not found`);
-      }
-      messagesToCopy = source.messages.slice(0, idx + 1);
-    }
-    const now = new Date;
-    const forkedMessages = messagesToCopy.map((m) => ({
-      ...m,
-      id: generateId("msg"),
-      conversationId: "",
-      createdAt: new Date(m.createdAt),
-      updatedAt: new Date(m.updatedAt)
-    }));
-    const forked = {
-      ...source,
-      id: generateId("conv"),
-      title: source.title ? `${source.title} (fork)` : undefined,
-      forkedFromId: source.id,
-      createdAt: now,
-      updatedAt: now,
-      messages: forkedMessages
-    };
-    for (const m of forked.messages) {
-      m.conversationId = forked.id;
-    }
-    this.conversations.set(forked.id, forked);
-    return forked;
-  }
-  async truncateAfter(conversationId, messageId) {
-    const conv = this.conversations.get(conversationId);
-    if (!conv)
-      return null;
-    const idx = conv.messages.findIndex((m) => m.id === messageId);
-    if (idx === -1)
-      return null;
-    conv.messages = conv.messages.slice(0, idx + 1);
-    conv.updatedAt = new Date;
-    return conv;
-  }
-  async search(query, limit = 20) {
-    const lowerQuery = query.toLowerCase();
-    const results = [];
-    for (const conversation of this.conversations.values()) {
-      if (conversation.title?.toLowerCase().includes(lowerQuery)) {
-        results.push(conversation);
-        continue;
-      }
-      const hasMatch = conversation.messages.some((m) => m.content.toLowerCase().includes(lowerQuery));
-      if (hasMatch) {
-        results.push(conversation);
-      }
-      if (results.length >= limit)
-        break;
-    }
-    return results;
-  }
-  clear() {
-    this.conversations.clear();
-  }
-}
-function createInMemoryConversationStore() {
-  return new InMemoryConversationStore;
-}
-
-// src/core/surface-planner-tools.ts
-import { buildSurfacePatchProposal } from "@contractspec/lib.surface-runtime/runtime/planner-tools";
-import {
-  validatePatchProposal
-} from "@contractspec/lib.surface-runtime/spec/validate-surface-patch";
-import { tool as tool2 } from "ai";
-import { z as z2 } from "zod";
-var VALID_OPS = [
-  "insert-node",
-  "replace-node",
-  "remove-node",
-  "move-node",
-  "resize-panel",
-  "set-layout",
-  "reveal-field",
-  "hide-field",
-  "promote-action",
-  "set-focus"
-];
-var DEFAULT_NODE_KINDS = [
-  "entity-section",
-  "entity-card",
-  "data-view",
-  "assistant-panel",
-  "chat-thread",
-  "action-bar",
-  "timeline",
-  "table",
-  "rich-doc",
-  "form",
-  "chart",
-  "custom-widget"
-];
-function collectSlotIdsFromRegion(node) {
-  const ids = [];
-  if (node.type === "slot") {
-    ids.push(node.slotId);
-  }
-  if (node.type === "panel-group" || node.type === "stack") {
-    for (const child of node.children) {
-      ids.push(...collectSlotIdsFromRegion(child));
-    }
-  }
-  if (node.type === "tabs") {
-    for (const tab of node.tabs) {
-      ids.push(...collectSlotIdsFromRegion(tab.child));
-    }
-  }
-  if (node.type === "floating") {
-    ids.push(node.anchorSlotId);
-    ids.push(...collectSlotIdsFromRegion(node.child));
-  }
-  return ids;
-}
-function deriveConstraints(plan) {
-  const slotIds = collectSlotIdsFromRegion(plan.layoutRoot);
-  const uniqueSlots = [...new Set(slotIds)];
-  return {
-    allowedOps: VALID_OPS,
-    allowedSlots: uniqueSlots.length > 0 ? uniqueSlots : ["assistant", "primary"],
-    allowedNodeKinds: DEFAULT_NODE_KINDS
-  };
-}
-var ProposePatchInputSchema = z2.object({
-  proposalId: z2.string().describe("Unique proposal identifier"),
-  ops: z2.array(z2.object({
-    op: z2.enum([
-      "insert-node",
-      "replace-node",
-      "remove-node",
-      "move-node",
-      "resize-panel",
-      "set-layout",
-      "reveal-field",
-      "hide-field",
-      "promote-action",
-      "set-focus"
-    ]),
-    slotId: z2.string().optional(),
-    nodeId: z2.string().optional(),
-    toSlotId: z2.string().optional(),
-    index: z2.number().optional(),
-    node: z2.object({
-      nodeId: z2.string(),
-      kind: z2.string(),
-      title: z2.string().optional(),
-      props: z2.record(z2.string(), z2.unknown()).optional(),
-      children: z2.array(z2.unknown()).optional()
-    }).optional(),
-    persistKey: z2.string().optional(),
-    sizes: z2.array(z2.number()).optional(),
-    layoutId: z2.string().optional(),
-    fieldId: z2.string().optional(),
-    actionId: z2.string().optional(),
-    placement: z2.enum(["header", "inline", "context", "assistant"]).optional(),
-    targetId: z2.string().optional()
-  }))
-});
-function createSurfacePlannerTools(config) {
-  const { plan, constraints, onPatchProposal } = config;
-  const resolvedConstraints = constraints ?? deriveConstraints(plan);
-  const proposePatchTool = tool2({
-    description: "Propose surface patches (layout changes, node insertions, etc.) for user approval. " + "Only use allowed ops, slots, and node kinds from the planner context.",
-    inputSchema: ProposePatchInputSchema,
-    execute: async (input) => {
-      const ops = input.ops;
-      try {
-        validatePatchProposal(ops, resolvedConstraints);
-        const proposal = buildSurfacePatchProposal(input.proposalId, ops);
-        onPatchProposal?.(proposal);
-        return {
-          success: true,
-          proposalId: proposal.proposalId,
-          opsCount: proposal.ops.length,
-          message: "Patch proposal validated; awaiting user approval"
-        };
-      } catch (err) {
-        return {
-          success: false,
-          error: err instanceof Error ? err.message : String(err),
-          proposalId: input.proposalId
-        };
-      }
-    }
-  });
-  return {
-    "propose-patch": proposePatchTool
-  };
-}
-function buildPlannerPromptInput(plan) {
-  const constraints = deriveConstraints(plan);
-  return {
-    bundleMeta: {
-      key: plan.bundleKey,
-      version: "0.0.0",
-      title: plan.bundleKey
-    },
-    surfaceId: plan.surfaceId,
-    allowedPatchOps: constraints.allowedOps,
-    allowedSlots: [...constraints.allowedSlots],
-    allowedNodeKinds: [...constraints.allowedNodeKinds],
-    actions: plan.actions.map((a) => ({
-      actionId: a.actionId,
-      title: a.title
-    })),
-    preferences: {
-      guidance: "hints",
-      density: "standard",
-      dataDepth: "detailed",
-      control: "standard",
-      media: "text",
-      pace: "balanced",
-      narrative: "top-down"
-    }
-  };
-}
-
-// src/core/thinking-levels.ts
-var THINKING_LEVEL_LABELS = {
-  instant: "Instant",
-  thinking: "Thinking",
-  extra_thinking: "Extra Thinking",
-  max: "Max"
-};
-var THINKING_LEVEL_DESCRIPTIONS = {
-  instant: "Fast responses, minimal reasoning",
-  thinking: "Standard reasoning depth",
-  extra_thinking: "More thorough reasoning",
-  max: "Maximum reasoning depth"
-};
-function getProviderOptions(level, providerName) {
-  if (!level || level === "instant") {
-    return {};
-  }
-  switch (providerName) {
-    case "anthropic": {
-      const budgetMap = {
-        thinking: 8000,
-        extra_thinking: 16000,
-        max: 32000
-      };
-      return {
-        anthropic: {
-          thinking: { type: "enabled", budgetTokens: budgetMap[level] }
-        }
-      };
-    }
-    case "openai": {
-      const effortMap = {
-        thinking: "low",
-        extra_thinking: "medium",
-        max: "high"
-      };
-      return {
-        openai: {
-          reasoningEffort: effortMap[level]
-        }
-      };
-    }
-    case "ollama":
-    case "mistral":
-    case "gemini":
-      return {};
-    default:
-      return {};
-  }
-}
-
-// src/core/workflow-tools.ts
-import {
-  validateExtension,
-  WorkflowComposer
-} from "@contractspec/lib.workflow-composer";
-import { tool as tool3 } from "ai";
-import { z as z3 } from "zod";
-var StepTypeSchema = z3.enum(["human", "automation", "decision"]);
-var StepActionSchema = z3.object({
-  operation: z3.object({
-    name: z3.string(),
-    version: z3.number()
-  }).optional(),
-  form: z3.object({
-    key: z3.string(),
-    version: z3.number()
-  }).optional()
-}).optional();
-var StepSchema = z3.object({
-  id: z3.string(),
-  type: StepTypeSchema,
-  label: z3.string(),
-  description: z3.string().optional(),
-  action: StepActionSchema
-});
-var StepInjectionSchema = z3.object({
-  after: z3.string().optional(),
-  before: z3.string().optional(),
-  inject: StepSchema,
-  transitionTo: z3.string().optional(),
-  transitionFrom: z3.string().optional(),
-  when: z3.string().optional()
-});
-var WorkflowExtensionInputSchema = z3.object({
-  workflow: z3.string(),
-  tenantId: z3.string().optional(),
-  role: z3.string().optional(),
-  priority: z3.number().optional(),
-  customSteps: z3.array(StepInjectionSchema).optional(),
-  hiddenSteps: z3.array(z3.string()).optional()
-});
-function createWorkflowTools(config) {
-  const { baseWorkflows, composer } = config;
-  const baseByKey = new Map(baseWorkflows.map((b) => [b.meta.key, b]));
-  const createWorkflowExtensionTool = tool3({
-    description: "Create or validate a workflow extension. Use when the user asks to add steps, modify a workflow, or create a tenant-specific extension. The extension targets an existing base workflow.",
-    inputSchema: WorkflowExtensionInputSchema,
-    execute: async (input) => {
-      const extension = {
-        workflow: input.workflow,
-        tenantId: input.tenantId,
-        role: input.role,
-        priority: input.priority,
-        customSteps: input.customSteps,
-        hiddenSteps: input.hiddenSteps
-      };
-      const base = baseByKey.get(input.workflow);
-      if (!base) {
-        return {
-          success: false,
-          error: `Base workflow "${input.workflow}" not found. Available: ${Array.from(baseByKey.keys()).join(", ")}`,
-          extension
-        };
-      }
-      try {
-        validateExtension(extension, base);
-        return {
-          success: true,
-          message: "Extension validated successfully",
-          extension
-        };
-      } catch (err) {
-        return {
-          success: false,
-          error: err instanceof Error ? err.message : String(err),
-          extension
-        };
-      }
-    }
-  });
-  const composeWorkflowInputSchema = z3.object({
-    workflowKey: z3.string().describe("Base workflow meta.key"),
-    tenantId: z3.string().optional(),
-    role: z3.string().optional(),
-    extensions: z3.array(WorkflowExtensionInputSchema).optional().describe("Extensions to register before composing")
-  });
-  const composeWorkflowTool = tool3({
-    description: "Compose a workflow by applying registered extensions to a base workflow. Returns the composed WorkflowSpec.",
-    inputSchema: composeWorkflowInputSchema,
-    execute: async (input) => {
-      const base = baseByKey.get(input.workflowKey);
-      if (!base) {
-        return {
-          success: false,
-          error: `Base workflow "${input.workflowKey}" not found. Available: ${Array.from(baseByKey.keys()).join(", ")}`
-        };
-      }
-      const comp = composer ?? new WorkflowComposer;
-      if (input.extensions?.length) {
-        for (const ext of input.extensions) {
-          comp.register({
-            workflow: ext.workflow,
-            tenantId: ext.tenantId,
-            role: ext.role,
-            priority: ext.priority,
-            customSteps: ext.customSteps,
-            hiddenSteps: ext.hiddenSteps
-          });
-        }
-      }
-      try {
-        const composed = comp.compose({
-          base,
-          tenantId: input.tenantId,
-          role: input.role
-        });
-        return {
-          success: true,
-          workflow: composed,
-          meta: composed.meta,
-          stepIds: composed.definition.steps.map((s) => s.id)
-        };
-      } catch (err) {
-        return {
-          success: false,
-          error: err instanceof Error ? err.message : String(err)
-        };
-      }
-    }
-  });
-  const generateWorkflowSpecCodeInputSchema = z3.object({
-    workflowKey: z3.string().describe("Workflow meta.key"),
-    composedSteps: z3.array(z3.object({
-      id: z3.string(),
-      type: z3.enum(["human", "automation", "decision"]),
-      label: z3.string(),
-      description: z3.string().optional()
-    })).optional().describe("Steps to include; if omitted, uses the base workflow")
-  });
-  const generateWorkflowSpecCodeTool = tool3({
-    description: "Generate TypeScript code for a workflow spec. Use after composing a workflow to output the spec as code the user can save.",
-    inputSchema: generateWorkflowSpecCodeInputSchema,
-    execute: async (input) => {
-      const base = baseByKey.get(input.workflowKey);
-      if (!base) {
-        return {
-          success: false,
-          error: `Base workflow "${input.workflowKey}" not found. Available: ${Array.from(baseByKey.keys()).join(", ")}`,
-          code: null
-        };
-      }
-      const steps = input.composedSteps ?? base.definition.steps;
-      const specVarName = toPascalCase((base.meta.key.split(".").pop() ?? "Workflow") + "") + "Workflow";
-      const stepsCode = steps.map((s) => `    {
-      id: '${s.id}',
-      type: '${s.type}',
-      label: '${escapeString(s.label)}',${s.description ? `
-      description: '${escapeString(s.description)}',` : ""}
+import{createRequire as PX}from"node:module";var xX=PX(import.meta.url);import{useCompletion as aZ}from"@ai-sdk/react";import{createProvider as tX}from"@contractspec/lib.ai-providers";import{tool as sX}from"ai";import*as E from"react";import{z as oX}from"zod";import{generateText as cX,streamText as iX}from"ai";import{compilePlannerPrompt as aX}from"@contractspec/lib.surface-runtime/runtime/planner-prompt";import{tool as bX}from"ai";import{z as kX}from"zod";function TX(X){return kX.object({}).passthrough()}function qX(X,Z){let $={};for(let J of X){let Y=Z?.[J.name],G=TX(J.schema);$[J.name]=bX({description:J.description??J.name,inputSchema:G,execute:async(j)=>{if(!Y)return{status:"unimplemented",message:"Wire handler in host",toolName:J.name};try{let H=await Promise.resolve(Y(j));return typeof H==="string"?H:H}catch(H){return{status:"error",error:H instanceof Error?H.message:String(H),toolName:J.name}}}})}return $}function BX(X){let Z=[];if(!X.agentSpecs?.length&&!X.dataViewSpecs?.length&&!X.formSpecs?.length&&!X.presentationSpecs?.length&&!X.operationRefs?.length)return"";if(Z.push(`
+
+## Available resources`),X.agentSpecs?.length){Z.push(`
+### Agent tools`);for(let $ of X.agentSpecs){let J=$.tools?.map((Y)=>Y.name).join(", ")??"none";Z.push(`- **${$.key}**: tools: ${J}`)}}if(X.dataViewSpecs?.length){Z.push(`
+### Data views`);for(let $ of X.dataViewSpecs)Z.push(`- **${$.key}**: ${$.meta.title??$.key}`)}if(X.formSpecs?.length){Z.push(`
+### Forms`);for(let $ of X.formSpecs)Z.push(`- **${$.key}**: ${$.meta.title??$.key}`)}if(X.presentationSpecs?.length){Z.push(`
+### Presentations`);for(let $ of X.presentationSpecs)Z.push(`- **${$.key}**: ${$.meta.title??$.key} (targets: ${$.targets?.join(", ")??"react"})`)}if(X.operationRefs?.length){Z.push(`
+### Operations`);for(let $ of X.operationRefs)Z.push(`- **${$.key}@${$.version}**`)}return Z.push(`
+Use the available tools to invoke operations, query data views, or propose surface changes when appropriate.`),Z.join(`
+`)}function s(X){return`${X}_${Date.now()}_${Math.random().toString(36).slice(2,11)}`}class o{conversations=new Map;async get(X){return this.conversations.get(X)??null}async create(X){let Z=new Date,$={...X,id:s("conv"),createdAt:Z,updatedAt:Z};return this.conversations.set($.id,$),$}async update(X,Z){let $=this.conversations.get(X);if(!$)return null;let J={...$,...Z,updatedAt:new Date};return this.conversations.set(X,J),J}async appendMessage(X,Z){let $=this.conversations.get(X);if(!$)throw Error(`Conversation ${X} not found`);let J=new Date,Y={...Z,id:s("msg"),conversationId:X,createdAt:J,updatedAt:J};return $.messages.push(Y),$.updatedAt=J,Y}async updateMessage(X,Z,$){let J=this.conversations.get(X);if(!J)return null;let Y=J.messages.findIndex((H)=>H.id===Z);if(Y===-1)return null;let G=J.messages[Y];if(!G)return null;let j={...G,...$,updatedAt:new Date};return J.messages[Y]=j,J.updatedAt=new Date,j}async delete(X){return this.conversations.delete(X)}async list(X){let Z=Array.from(this.conversations.values());if(X?.status)Z=Z.filter((Y)=>Y.status===X.status);if(X?.projectId)Z=Z.filter((Y)=>Y.projectId===X.projectId);if(X?.tags&&X.tags.length>0){let Y=new Set(X.tags);Z=Z.filter((G)=>G.tags&&G.tags.some((j)=>Y.has(j)))}Z.sort((Y,G)=>G.updatedAt.getTime()-Y.updatedAt.getTime());let $=X?.offset??0,J=X?.limit??100;return Z.slice($,$+J)}async fork(X,Z){let $=this.conversations.get(X);if(!$)throw Error(`Conversation ${X} not found`);let J=$.messages;if(Z){let H=$.messages.findIndex((q)=>q.id===Z);if(H===-1)throw Error(`Message ${Z} not found`);J=$.messages.slice(0,H+1)}let Y=new Date,G=J.map((H)=>({...H,id:s("msg"),conversationId:"",createdAt:new Date(H.createdAt),updatedAt:new Date(H.updatedAt)})),j={...$,id:s("conv"),title:$.title?`${$.title} (fork)`:void 0,forkedFromId:$.id,createdAt:Y,updatedAt:Y,messages:G};for(let H of j.messages)H.conversationId=j.id;return this.conversations.set(j.id,j),j}async truncateAfter(X,Z){let $=this.conversations.get(X);if(!$)return null;let J=$.messages.findIndex((Y)=>Y.id===Z);if(J===-1)return null;return $.messages=$.messages.slice(0,J+1),$.updatedAt=new Date,$}async search(X,Z=20){let $=X.toLowerCase(),J=[];for(let Y of this.conversations.values()){if(Y.title?.toLowerCase().includes($)){J.push(Y);continue}if(Y.messages.some((j)=>j.content.toLowerCase().includes($)))J.push(Y);if(J.length>=Z)break}return J}clear(){this.conversations.clear()}}function _Z(){return new o}import{buildSurfacePatchProposal as SX}from"@contractspec/lib.surface-runtime/runtime/planner-tools";import{validatePatchProposal as hX}from"@contractspec/lib.surface-runtime/spec/validate-surface-patch";import{tool as CX}from"ai";import{z as K}from"zod";var MX=["insert-node","replace-node","remove-node","move-node","resize-panel","set-layout","reveal-field","hide-field","promote-action","set-focus"],IX=["entity-section","entity-card","data-view","assistant-panel","chat-thread","action-bar","timeline","table","rich-doc","form","chart","custom-widget"];function e(X){let Z=[];if(X.type==="slot")Z.push(X.slotId);if(X.type==="panel-group"||X.type==="stack")for(let $ of X.children)Z.push(...e($));if(X.type==="tabs")for(let $ of X.tabs)Z.push(...e($.child));if(X.type==="floating")Z.push(X.anchorSlotId),Z.push(...e(X.child));return Z}function _X(X){let Z=e(X.layoutRoot),$=[...new Set(Z)];return{allowedOps:MX,allowedSlots:$.length>0?$:["assistant","primary"],allowedNodeKinds:IX}}var fX=K.object({proposalId:K.string().describe("Unique proposal identifier"),ops:K.array(K.object({op:K.enum(["insert-node","replace-node","remove-node","move-node","resize-panel","set-layout","reveal-field","hide-field","promote-action","set-focus"]),slotId:K.string().optional(),nodeId:K.string().optional(),toSlotId:K.string().optional(),index:K.number().optional(),node:K.object({nodeId:K.string(),kind:K.string(),title:K.string().optional(),props:K.record(K.string(),K.unknown()).optional(),children:K.array(K.unknown()).optional()}).optional(),persistKey:K.string().optional(),sizes:K.array(K.number()).optional(),layoutId:K.string().optional(),fieldId:K.string().optional(),actionId:K.string().optional(),placement:K.enum(["header","inline","context","assistant"]).optional(),targetId:K.string().optional()}))});function NX(X){let{plan:Z,constraints:$,onPatchProposal:J}=X,Y=$??_X(Z);return{"propose-patch":CX({description:"Propose surface patches (layout changes, node insertions, etc.) for user approval. Only use allowed ops, slots, and node kinds from the planner context.",inputSchema:fX,execute:async(j)=>{let H=j.ops;try{hX(H,Y);let q=SX(j.proposalId,H);return J?.(q),{success:!0,proposalId:q.proposalId,opsCount:q.ops.length,message:"Patch proposal validated; awaiting user approval"}}catch(q){return{success:!1,error:q instanceof Error?q.message:String(q),proposalId:j.proposalId}}}})}}function UX(X){let Z=_X(X);return{bundleMeta:{key:X.bundleKey,version:"0.0.0",title:X.bundleKey},surfaceId:X.surfaceId,allowedPatchOps:Z.allowedOps,allowedSlots:[...Z.allowedSlots],allowedNodeKinds:[...Z.allowedNodeKinds],actions:X.actions.map(($)=>({actionId:$.actionId,title:$.title})),preferences:{guidance:"hints",density:"standard",dataDepth:"detailed",control:"standard",media:"text",pace:"balanced",narrative:"top-down"}}}var KZ={instant:"Instant",thinking:"Thinking",extra_thinking:"Extra Thinking",max:"Max"},OZ={instant:"Fast responses, minimal reasoning",thinking:"Standard reasoning depth",extra_thinking:"More thorough reasoning",max:"Maximum reasoning depth"};function GX(X,Z){if(!X||X==="instant")return{};switch(Z){case"anthropic":return{anthropic:{thinking:{type:"enabled",budgetTokens:{thinking:8000,extra_thinking:16000,max:32000}[X]}}};case"openai":return{openai:{reasoningEffort:{thinking:"low",extra_thinking:"medium",max:"high"}[X]}};case"ollama":case"mistral":case"gemini":return{};default:return{}}}import{validateExtension as mX,WorkflowComposer as uX}from"@contractspec/lib.workflow-composer";import{tool as QX}from"ai";import{z as B}from"zod";var vX=B.enum(["human","automation","decision"]),gX=B.object({operation:B.object({name:B.string(),version:B.number()}).optional(),form:B.object({key:B.string(),version:B.number()}).optional()}).optional(),dX=B.object({id:B.string(),type:vX,label:B.string(),description:B.string().optional(),action:gX}),lX=B.object({after:B.string().optional(),before:B.string().optional(),inject:dX,transitionTo:B.string().optional(),transitionFrom:B.string().optional(),when:B.string().optional()}),WX=B.object({workflow:B.string(),tenantId:B.string().optional(),role:B.string().optional(),priority:B.number().optional(),customSteps:B.array(lX).optional(),hiddenSteps:B.array(B.string()).optional()});function DX(X){let{baseWorkflows:Z,composer:$}=X,J=new Map(Z.map((Q)=>[Q.meta.key,Q])),Y=QX({description:"Create or validate a workflow extension. Use when the user asks to add steps, modify a workflow, or create a tenant-specific extension. The extension targets an existing base workflow.",inputSchema:WX,execute:async(Q)=>{let _={workflow:Q.workflow,tenantId:Q.tenantId,role:Q.role,priority:Q.priority,customSteps:Q.customSteps,hiddenSteps:Q.hiddenSteps},A=J.get(Q.workflow);if(!A)return{success:!1,error:`Base workflow "${Q.workflow}" not found. Available: ${Array.from(J.keys()).join(", ")}`,extension:_};try{return mX(_,A),{success:!0,message:"Extension validated successfully",extension:_}}catch(N){return{success:!1,error:N instanceof Error?N.message:String(N),extension:_}}}}),G=B.object({workflowKey:B.string().describe("Base workflow meta.key"),tenantId:B.string().optional(),role:B.string().optional(),extensions:B.array(WX).optional().describe("Extensions to register before composing")}),j=QX({description:"Compose a workflow by applying registered extensions to a base workflow. Returns the composed WorkflowSpec.",inputSchema:G,execute:async(Q)=>{let _=J.get(Q.workflowKey);if(!_)return{success:!1,error:`Base workflow "${Q.workflowKey}" not found. Available: ${Array.from(J.keys()).join(", ")}`};let A=$??new uX;if(Q.extensions?.length)for(let N of Q.extensions)A.register({workflow:N.workflow,tenantId:N.tenantId,role:N.role,priority:N.priority,customSteps:N.customSteps,hiddenSteps:N.hiddenSteps});try{let N=A.compose({base:_,tenantId:Q.tenantId,role:Q.role});return{success:!0,workflow:N,meta:N.meta,stepIds:N.definition.steps.map((k)=>k.id)}}catch(N){return{success:!1,error:N instanceof Error?N.message:String(N)}}}}),H=B.object({workflowKey:B.string().describe("Workflow meta.key"),composedSteps:B.array(B.object({id:B.string(),type:B.enum(["human","automation","decision"]),label:B.string(),description:B.string().optional()})).optional().describe("Steps to include; if omitted, uses the base workflow")}),q=QX({description:"Generate TypeScript code for a workflow spec. Use after composing a workflow to output the spec as code the user can save.",inputSchema:H,execute:async(Q)=>{let _=J.get(Q.workflowKey);if(!_)return{success:!1,error:`Base workflow "${Q.workflowKey}" not found. Available: ${Array.from(J.keys()).join(", ")}`,code:null};let A=Q.composedSteps??_.definition.steps,N=pX((_.meta.key.split(".").pop()??"Workflow")+"")+"Workflow",k=A.map((U)=>`    {
+      id: '${U.id}',
+      type: '${U.type}',
+      label: '${XX(U.label)}',${U.description?`
+      description: '${XX(U.description)}',`:""}
     }`).join(`,
-`);
-      const meta = base.meta;
-      const transitionsJson = JSON.stringify(base.definition.transitions, null, 6);
-      const code = `import type { WorkflowSpec } from '@contractspec/lib.contracts-spec/workflow/spec';
+`),P=_.meta,I=JSON.stringify(_.definition.transitions,null,6);return{success:!0,code:`import type { WorkflowSpec } from '@contractspec/lib.contracts-spec/workflow/spec';
 
 /**
- * Workflow: ${base.meta.key}
+ * Workflow: ${_.meta.key}
  * Generated via AI chat workflow tools.
  */
-export const ${specVarName}: WorkflowSpec = {
+export const ${N}: WorkflowSpec = {
   meta: {
-    key: '${base.meta.key}',
-    version: '${String(base.meta.version)}',
-    title: '${escapeString(meta.title ?? base.meta.key)}',
-    description: '${escapeString(meta.description ?? "")}',
+    key: '${_.meta.key}',
+    version: '${String(_.meta.version)}',
+    title: '${XX(P.title??_.meta.key)}',
+    description: '${XX(P.description??"")}',
   },
   definition: {
-    entryStepId: '${base.definition.entryStepId ?? base.definition.steps[0]?.id ?? ""}',
+    entryStepId: '${_.definition.entryStepId??_.definition.steps[0]?.id??""}',
     steps: [
-${stepsCode}
+${k}
     ],
-    transitions: ${transitionsJson},
+    transitions: ${I},
   },
 };
-`;
-      return {
-        success: true,
-        code,
-        workflowKey: input.workflowKey
-      };
-    }
-  });
-  return {
-    create_workflow_extension: createWorkflowExtensionTool,
-    compose_workflow: composeWorkflowTool,
-    generate_workflow_spec_code: generateWorkflowSpecCodeTool
-  };
-}
-function toPascalCase(value) {
-  return value.split(/[-_.]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function escapeString(value) {
-  return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-}
-
-// src/core/chat-service.ts
-var DEFAULT_SYSTEM_PROMPT = `You are ContractSpec AI, an expert coding assistant specialized in ContractSpec development.
+`,workflowKey:Q.workflowKey}}});return{create_workflow_extension:Y,compose_workflow:j,generate_workflow_spec_code:q}}function pX(X){return X.split(/[-_.]/).filter(Boolean).map((Z)=>Z.charAt(0).toUpperCase()+Z.slice(1)).join("")}function XX(X){return X.replace(/\\/g,"\\\\").replace(/'/g,"\\'")}var rX=`You are ContractSpec AI, an expert coding assistant specialized in ContractSpec development.
 
 Your capabilities:
 - Help users create, modify, and understand ContractSpec specifications
@@ -692,971 +47,15 @@ Guidelines:
 - Provide code examples when helpful
 - Reference relevant ContractSpec concepts and patterns
 - Ask clarifying questions when the user's intent is unclear
-- When suggesting code changes, explain the rationale`;
-var WORKFLOW_TOOLS_PROMPT = `
-
-Workflow creation: You can create and modify workflows. Use create_workflow_extension when the user asks to add steps, change a workflow, or create a tenant-specific extension. Use compose_workflow to apply extensions to a base workflow. Use generate_workflow_spec_code to output TypeScript for the user to save.`;
+- When suggesting code changes, explain the rationale`,nX=`
 
-class ChatService {
-  provider;
-  context;
-  store;
-  systemPrompt;
-  maxHistoryMessages;
-  onUsage;
-  tools;
-  thinkingLevel;
-  sendReasoning;
-  sendSources;
-  modelSelector;
-  constructor(config) {
-    this.provider = config.provider;
-    this.context = config.context;
-    this.store = config.store ?? new InMemoryConversationStore;
-    this.systemPrompt = this.buildSystemPrompt(config);
-    this.maxHistoryMessages = config.maxHistoryMessages ?? 20;
-    this.onUsage = config.onUsage;
-    this.tools = this.mergeTools(config);
-    this.thinkingLevel = config.thinkingLevel;
-    this.modelSelector = config.modelSelector;
-    this.sendReasoning = config.sendReasoning ?? (config.thinkingLevel != null && config.thinkingLevel !== "instant");
-    this.sendSources = config.sendSources ?? false;
-  }
-  buildSystemPrompt(config) {
-    let base = config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
-    if (config.workflowToolsConfig?.baseWorkflows?.length) {
-      base += WORKFLOW_TOOLS_PROMPT;
-    }
-    const contractsPrompt = buildContractsContextPrompt(config.contractsContext ?? {});
-    if (contractsPrompt) {
-      base += contractsPrompt;
-    }
-    if (config.surfacePlanConfig?.plan) {
-      const plannerInput = buildPlannerPromptInput(config.surfacePlanConfig.plan);
-      base += `
+Workflow creation: You can create and modify workflows. Use create_workflow_extension when the user asks to add steps, change a workflow, or create a tenant-specific extension. Use compose_workflow to apply extensions to a base workflow. Use generate_workflow_spec_code to output TypeScript for the user to save.`;class ZX{provider;context;store;systemPrompt;maxHistoryMessages;onUsage;tools;thinkingLevel;sendReasoning;sendSources;modelSelector;constructor(X){this.provider=X.provider,this.context=X.context,this.store=X.store??new o,this.systemPrompt=this.buildSystemPrompt(X),this.maxHistoryMessages=X.maxHistoryMessages??20,this.onUsage=X.onUsage,this.tools=this.mergeTools(X),this.thinkingLevel=X.thinkingLevel,this.modelSelector=X.modelSelector,this.sendReasoning=X.sendReasoning??(X.thinkingLevel!=null&&X.thinkingLevel!=="instant"),this.sendSources=X.sendSources??!1}buildSystemPrompt(X){let Z=X.systemPrompt??rX;if(X.workflowToolsConfig?.baseWorkflows?.length)Z+=nX;let $=BX(X.contractsContext??{});if($)Z+=$;if(X.surfacePlanConfig?.plan){let J=UX(X.surfacePlanConfig.plan);Z+=`
 
-` + compilePlannerPrompt(plannerInput);
-    }
-    return base;
-  }
-  mergeTools(config) {
-    let merged = config.tools ?? {};
-    const wfConfig = config.workflowToolsConfig;
-    if (wfConfig?.baseWorkflows?.length) {
-      const workflowTools = createWorkflowTools({
-        baseWorkflows: wfConfig.baseWorkflows,
-        composer: wfConfig.composer
-      });
-      merged = { ...merged, ...workflowTools };
-    }
-    const contractsCtx = config.contractsContext;
-    if (contractsCtx?.agentSpecs?.length) {
-      const allTools = [];
-      for (const agent of contractsCtx.agentSpecs) {
-        if (agent.tools?.length)
-          allTools.push(...agent.tools);
-      }
-      if (allTools.length > 0) {
-        const agentTools = agentToolConfigsToToolSet(allTools);
-        merged = { ...merged, ...agentTools };
-      }
-    }
-    const surfaceConfig = config.surfacePlanConfig;
-    if (surfaceConfig?.plan) {
-      const plannerTools = createSurfacePlannerTools({
-        plan: surfaceConfig.plan,
-        onPatchProposal: surfaceConfig.onPatchProposal
-      });
-      merged = { ...merged, ...plannerTools };
-    }
-    if (config.mcpTools && Object.keys(config.mcpTools).length > 0) {
-      merged = { ...merged, ...config.mcpTools };
-    }
-    return Object.keys(merged).length > 0 ? merged : undefined;
-  }
-  async resolveModel() {
-    if (this.modelSelector) {
-      const dimension = this.thinkingLevelToDimension(this.thinkingLevel);
-      const { model, selection } = await this.modelSelector.selectAndCreate({
-        taskDimension: dimension
-      });
-      return { model, providerName: selection.providerKey };
-    }
-    return {
-      model: this.provider.getModel(),
-      providerName: this.provider.name
-    };
-  }
-  thinkingLevelToDimension(level) {
-    if (!level || level === "instant")
-      return "latency";
-    return "reasoning";
-  }
-  async send(options) {
-    let conversation;
-    if (options.conversationId) {
-      const existing = await this.store.get(options.conversationId);
-      if (!existing) {
-        throw new Error(`Conversation ${options.conversationId} not found`);
-      }
-      conversation = existing;
-    } else {
-      conversation = await this.store.create({
-        status: "active",
-        provider: this.provider.name,
-        model: this.provider.model,
-        messages: [],
-        workspacePath: this.context?.workspacePath
-      });
-    }
-    if (!options.skipUserAppend) {
-      await this.store.appendMessage(conversation.id, {
-        role: "user",
-        content: options.content,
-        status: "completed",
-        attachments: options.attachments
-      });
-    }
-    conversation = await this.store.get(conversation.id) ?? conversation;
-    const messages = this.buildMessages(conversation, options);
-    const { model, providerName } = await this.resolveModel();
-    const providerOptions = getProviderOptions(this.thinkingLevel, providerName);
-    try {
-      const result = await generateText({
-        model,
-        messages,
-        system: this.systemPrompt,
-        tools: this.tools,
-        providerOptions: Object.keys(providerOptions).length > 0 ? providerOptions : undefined
-      });
-      const assistantMessage = await this.store.appendMessage(conversation.id, {
-        role: "assistant",
-        content: result.text,
-        status: "completed"
-      });
-      const updatedConversation = await this.store.get(conversation.id);
-      if (!updatedConversation) {
-        throw new Error("Conversation lost after update");
-      }
-      return {
-        message: assistantMessage,
-        conversation: updatedConversation
-      };
-    } catch (error) {
-      await this.store.appendMessage(conversation.id, {
-        role: "assistant",
-        content: "",
-        status: "error",
-        error: {
-          code: "generation_failed",
-          message: error instanceof Error ? error.message : String(error)
-        }
-      });
-      throw error;
-    }
-  }
-  async stream(options) {
-    let conversation;
-    if (options.conversationId) {
-      const existing = await this.store.get(options.conversationId);
-      if (!existing) {
-        throw new Error(`Conversation ${options.conversationId} not found`);
-      }
-      conversation = existing;
-    } else {
-      conversation = await this.store.create({
-        status: "active",
-        provider: this.provider.name,
-        model: this.provider.model,
-        messages: [],
-        workspacePath: this.context?.workspacePath
-      });
-    }
-    if (!options.skipUserAppend) {
-      await this.store.appendMessage(conversation.id, {
-        role: "user",
-        content: options.content,
-        status: "completed",
-        attachments: options.attachments
-      });
-    }
-    conversation = await this.store.get(conversation.id) ?? conversation;
-    const assistantMessage = await this.store.appendMessage(conversation.id, {
-      role: "assistant",
-      content: "",
-      status: "streaming"
-    });
-    const messages = this.buildMessages(conversation, options);
-    const { model, providerName } = await this.resolveModel();
-    const systemPrompt = this.systemPrompt;
-    const tools = this.tools;
-    const store = this.store;
-    const onUsage = this.onUsage;
-    const streamProviderOptions = getProviderOptions(this.thinkingLevel, providerName);
-    async function* streamGenerator() {
-      let fullContent = "";
-      let fullReasoning = "";
-      const toolCallsMap = new Map;
-      const sources = [];
-      try {
-        const result = streamText({
-          model,
-          messages,
-          system: systemPrompt,
-          tools,
-          providerOptions: Object.keys(streamProviderOptions).length > 0 ? streamProviderOptions : undefined
-        });
-        for await (const part of result.fullStream) {
-          if (part.type === "text-delta") {
-            const text = part.text ?? "";
-            if (text) {
-              fullContent += text;
-              yield { type: "text", content: text };
-            }
-          } else if (part.type === "reasoning-delta") {
-            const text = part.text ?? "";
-            if (text) {
-              fullReasoning += text;
-              yield { type: "reasoning", content: text };
-            }
-          } else if (part.type === "source") {
-            const src = part;
-            const source = {
-              id: src.id,
-              title: src.title ?? "",
-              url: src.url,
-              type: "web"
-            };
-            sources.push(source);
-            yield { type: "source", source };
-          } else if (part.type === "tool-call") {
-            const toolCall = {
-              id: part.toolCallId,
-              name: part.toolName,
-              args: part.input ?? {},
-              status: "running"
-            };
-            toolCallsMap.set(part.toolCallId, toolCall);
-            yield { type: "tool_call", toolCall };
-          } else if (part.type === "tool-result") {
-            const tc = toolCallsMap.get(part.toolCallId);
-            if (tc) {
-              tc.result = part.output;
-              tc.status = "completed";
-            }
-            yield {
-              type: "tool_result",
-              toolResult: {
-                toolCallId: part.toolCallId,
-                toolName: part.toolName,
-                result: part.output
-              }
-            };
-          } else if (part.type === "tool-error") {
-            const tc = toolCallsMap.get(part.toolCallId);
-            if (tc) {
-              tc.status = "error";
-              tc.error = part.error ?? "Tool execution failed";
-            }
-          } else if (part.type === "finish") {
-            const usage = part.usage;
-            const inputTokens = usage?.inputTokens ?? 0;
-            const outputTokens = usage?.completionTokens ?? 0;
-            await store.updateMessage(conversation.id, assistantMessage.id, {
-              content: fullContent,
-              status: "completed",
-              reasoning: fullReasoning || undefined,
-              sources: sources.length > 0 ? sources : undefined,
-              toolCalls: toolCallsMap.size > 0 ? Array.from(toolCallsMap.values()) : undefined,
-              usage: usage ? { inputTokens, outputTokens } : undefined
-            });
-            onUsage?.({ inputTokens, outputTokens });
-            yield {
-              type: "done",
-              usage: usage ? { inputTokens, outputTokens } : undefined
-            };
-            return;
-          }
-        }
-        await store.updateMessage(conversation.id, assistantMessage.id, {
-          content: fullContent,
-          status: "completed",
-          reasoning: fullReasoning || undefined,
-          sources: sources.length > 0 ? sources : undefined,
-          toolCalls: toolCallsMap.size > 0 ? Array.from(toolCallsMap.values()) : undefined
-        });
-        yield { type: "done" };
-      } catch (error) {
-        await store.updateMessage(conversation.id, assistantMessage.id, {
-          content: fullContent,
-          status: "error",
-          error: {
-            code: "stream_failed",
-            message: error instanceof Error ? error.message : String(error)
-          }
-        });
-        yield {
-          type: "error",
-          error: {
-            code: "stream_failed",
-            message: error instanceof Error ? error.message : String(error)
-          }
-        };
-      }
-    }
-    return {
-      conversationId: conversation.id,
-      messageId: assistantMessage.id,
-      stream: streamGenerator()
-    };
-  }
-  async getConversation(conversationId) {
-    return this.store.get(conversationId);
-  }
-  async listConversations(options) {
-    return this.store.list({
-      status: "active",
-      ...options
-    });
-  }
-  async updateConversation(conversationId, updates) {
-    return this.store.update(conversationId, updates);
-  }
-  async forkConversation(conversationId, upToMessageId) {
-    return this.store.fork(conversationId, upToMessageId);
-  }
-  async updateMessage(conversationId, messageId, updates) {
-    return this.store.updateMessage(conversationId, messageId, updates);
-  }
-  async truncateAfter(conversationId, messageId) {
-    return this.store.truncateAfter(conversationId, messageId);
-  }
-  async deleteConversation(conversationId) {
-    return this.store.delete(conversationId);
-  }
-  buildMessages(conversation, _options) {
-    const historyStart = Math.max(0, conversation.messages.length - this.maxHistoryMessages);
-    const messages = [];
-    for (let i = historyStart;i < conversation.messages.length; i++) {
-      const msg = conversation.messages[i];
-      if (!msg)
-        continue;
-      if (msg.role === "user") {
-        let content = msg.content;
-        if (msg.attachments?.length) {
-          const attachmentInfo = msg.attachments.map((a) => {
-            if (a.type === "file" || a.type === "code") {
-              return `
+`+aX(J)}return Z}mergeTools(X){let Z=X.tools??{},$=X.workflowToolsConfig;if($?.baseWorkflows?.length){let G=DX({baseWorkflows:$.baseWorkflows,composer:$.composer});Z={...Z,...G}}let J=X.contractsContext;if(J?.agentSpecs?.length){let G=[];for(let j of J.agentSpecs)if(j.tools?.length)G.push(...j.tools);if(G.length>0){let j=qX(G);Z={...Z,...j}}}let Y=X.surfacePlanConfig;if(Y?.plan){let G=NX({plan:Y.plan,onPatchProposal:Y.onPatchProposal});Z={...Z,...G}}if(X.mcpTools&&Object.keys(X.mcpTools).length>0)Z={...Z,...X.mcpTools};return Object.keys(Z).length>0?Z:void 0}async resolveModel(){if(this.modelSelector){let X=this.thinkingLevelToDimension(this.thinkingLevel),{model:Z,selection:$}=await this.modelSelector.selectAndCreate({taskDimension:X});return{model:Z,providerName:$.providerKey}}return{model:this.provider.getModel(),providerName:this.provider.name}}thinkingLevelToDimension(X){if(!X||X==="instant")return"latency";return"reasoning"}async send(X){let Z;if(X.conversationId){let j=await this.store.get(X.conversationId);if(!j)throw Error(`Conversation ${X.conversationId} not found`);Z=j}else Z=await this.store.create({status:"active",provider:this.provider.name,model:this.provider.model,messages:[],workspacePath:this.context?.workspacePath});if(!X.skipUserAppend)await this.store.appendMessage(Z.id,{role:"user",content:X.content,status:"completed",attachments:X.attachments});Z=await this.store.get(Z.id)??Z;let $=this.buildMessages(Z,X),{model:J,providerName:Y}=await this.resolveModel(),G=GX(this.thinkingLevel,Y);try{let j=await cX({model:J,messages:$,system:this.systemPrompt,tools:this.tools,providerOptions:Object.keys(G).length>0?G:void 0}),H=await this.store.appendMessage(Z.id,{role:"assistant",content:j.text,status:"completed"}),q=await this.store.get(Z.id);if(!q)throw Error("Conversation lost after update");return{message:H,conversation:q}}catch(j){throw await this.store.appendMessage(Z.id,{role:"assistant",content:"",status:"error",error:{code:"generation_failed",message:j instanceof Error?j.message:String(j)}}),j}}async stream(X){let Z;if(X.conversationId){let N=await this.store.get(X.conversationId);if(!N)throw Error(`Conversation ${X.conversationId} not found`);Z=N}else Z=await this.store.create({status:"active",provider:this.provider.name,model:this.provider.model,messages:[],workspacePath:this.context?.workspacePath});if(!X.skipUserAppend)await this.store.appendMessage(Z.id,{role:"user",content:X.content,status:"completed",attachments:X.attachments});Z=await this.store.get(Z.id)??Z;let $=await this.store.appendMessage(Z.id,{role:"assistant",content:"",status:"streaming"}),J=this.buildMessages(Z,X),{model:Y,providerName:G}=await this.resolveModel(),j=this.systemPrompt,H=this.tools,q=this.store,Q=this.onUsage,_=GX(this.thinkingLevel,G);async function*A(){let N="",k="",P=new Map,I=[];try{let h=iX({model:Y,messages:J,system:j,tools:H,providerOptions:Object.keys(_).length>0?_:void 0});for await(let U of h.fullStream)if(U.type==="text-delta"){let W=U.text??"";if(W)N+=W,yield{type:"text",content:W}}else if(U.type==="reasoning-delta"){let W=U.text??"";if(W)k+=W,yield{type:"reasoning",content:W}}else if(U.type==="source"){let W=U,f={id:W.id,title:W.title??"",url:W.url,type:"web"};I.push(f),yield{type:"source",source:f}}else if(U.type==="tool-call"){let W={id:U.toolCallId,name:U.toolName,args:U.input??{},status:"running"};P.set(U.toolCallId,W),yield{type:"tool_call",toolCall:W}}else if(U.type==="tool-result"){let W=P.get(U.toolCallId);if(W)W.result=U.output,W.status="completed";yield{type:"tool_result",toolResult:{toolCallId:U.toolCallId,toolName:U.toolName,result:U.output}}}else if(U.type==="tool-error"){let W=P.get(U.toolCallId);if(W)W.status="error",W.error=U.error??"Tool execution failed"}else if(U.type==="finish"){let W=U.usage,f=W?.inputTokens??0,g=W?.completionTokens??0;await q.updateMessage(Z.id,$.id,{content:N,status:"completed",reasoning:k||void 0,sources:I.length>0?I:void 0,toolCalls:P.size>0?Array.from(P.values()):void 0,usage:W?{inputTokens:f,outputTokens:g}:void 0}),Q?.({inputTokens:f,outputTokens:g}),yield{type:"done",usage:W?{inputTokens:f,outputTokens:g}:void 0};return}await q.updateMessage(Z.id,$.id,{content:N,status:"completed",reasoning:k||void 0,sources:I.length>0?I:void 0,toolCalls:P.size>0?Array.from(P.values()):void 0}),yield{type:"done"}}catch(h){await q.updateMessage(Z.id,$.id,{content:N,status:"error",error:{code:"stream_failed",message:h instanceof Error?h.message:String(h)}}),yield{type:"error",error:{code:"stream_failed",message:h instanceof Error?h.message:String(h)}}}}return{conversationId:Z.id,messageId:$.id,stream:A()}}async getConversation(X){return this.store.get(X)}async listConversations(X){return this.store.list({status:"active",...X})}async updateConversation(X,Z){return this.store.update(X,Z)}async forkConversation(X,Z){return this.store.fork(X,Z)}async updateMessage(X,Z,$){return this.store.updateMessage(X,Z,$)}async truncateAfter(X,Z){return this.store.truncateAfter(X,Z)}async deleteConversation(X){return this.store.delete(X)}buildMessages(X,Z){let $=Math.max(0,X.messages.length-this.maxHistoryMessages),J=[];for(let Y=$;Y<X.messages.length;Y++){let G=X.messages[Y];if(!G)continue;if(G.role==="user"){let j=G.content;if(G.attachments?.length){let H=G.attachments.map((q)=>{if(q.type==="file"||q.type==="code")return`
 
-### ${a.name}
+### ${q.name}
 \`\`\`
-${a.content ?? ""}
-\`\`\``;
-            }
-            return `
+${q.content??""}
+\`\`\``;return`
 
-[Attachment: ${a.name}]`;
-          }).join("");
-          content += attachmentInfo;
-        }
-        messages.push({ role: "user", content });
-      } else if (msg.role === "assistant") {
-        if (msg.toolCalls?.length) {
-          messages.push({
-            role: "assistant",
-            content: msg.content || "",
-            toolCalls: msg.toolCalls.map((tc) => ({
-              type: "tool-call",
-              toolCallId: tc.id,
-              toolName: tc.name,
-              args: tc.args
-            }))
-          });
-          messages.push({
-            role: "tool",
-            content: msg.toolCalls.map((tc) => ({
-              type: "tool-result",
-              toolCallId: tc.id,
-              toolName: tc.name,
-              output: tc.result
-            }))
-          });
-        } else {
-          messages.push({ role: "assistant", content: msg.content });
-        }
-      }
-    }
-    return messages;
-  }
-}
-function createChatService(config) {
-  return new ChatService(config);
-}
-
-// src/presentation/hooks/useChat.tsx
-"use client";
-function toolsToToolSet(defs) {
-  const result = {};
-  for (const def of defs) {
-    result[def.name] = tool4({
-      description: def.description ?? def.name,
-      inputSchema: z4.object({}).passthrough(),
-      execute: async () => ({})
-    });
-  }
-  return result;
-}
-function useChat(options = {}) {
-  const {
-    provider = "openai",
-    mode = "byok",
-    model,
-    apiKey,
-    proxyUrl,
-    conversationId: initialConversationId,
-    store,
-    systemPrompt,
-    streaming = true,
-    onSend,
-    onResponse,
-    onError,
-    onUsage,
-    tools: toolsDefs,
-    thinkingLevel,
-    workflowToolsConfig,
-    modelSelector,
-    contractsContext,
-    surfacePlanConfig,
-    mcpServers,
-    agentMode
-  } = options;
-  const [messages, setMessages] = React.useState([]);
-  const [mcpTools, setMcpTools] = React.useState(null);
-  const mcpCleanupRef = React.useRef(null);
-  const [conversation, setConversation] = React.useState(null);
-  const [isLoading, setIsLoading] = React.useState(false);
-  const [error, setError] = React.useState(null);
-  const [conversationId, setConversationId] = React.useState(initialConversationId ?? null);
-  const abortControllerRef = React.useRef(null);
-  const chatServiceRef = React.useRef(null);
-  React.useEffect(() => {
-    if (!mcpServers?.length) {
-      setMcpTools(null);
-      return;
-    }
-    let cancelled = false;
-    import("@contractspec/lib.ai-agent/tools/mcp-client.browser").then(({ createMcpToolsets }) => {
-      createMcpToolsets(mcpServers).then(({ tools, cleanup }) => {
-        if (!cancelled) {
-          setMcpTools(tools);
-          mcpCleanupRef.current = cleanup;
-        } else {
-          cleanup().catch(() => {
-            return;
-          });
-        }
-      }).catch(() => {
-        if (!cancelled)
-          setMcpTools(null);
-      });
-    });
-    return () => {
-      cancelled = true;
-      const cleanup = mcpCleanupRef.current;
-      mcpCleanupRef.current = null;
-      if (cleanup)
-        cleanup().catch(() => {
-          return;
-        });
-      setMcpTools(null);
-    };
-  }, [mcpServers]);
-  React.useEffect(() => {
-    const chatProvider = createProvider({
-      provider,
-      model,
-      apiKey,
-      proxyUrl
-    });
-    chatServiceRef.current = new ChatService({
-      provider: chatProvider,
-      store,
-      systemPrompt,
-      onUsage,
-      tools: toolsDefs?.length ? toolsToToolSet(toolsDefs) : undefined,
-      thinkingLevel,
-      workflowToolsConfig,
-      modelSelector,
-      contractsContext,
-      surfacePlanConfig,
-      mcpTools
-    });
-  }, [
-    provider,
-    mode,
-    model,
-    apiKey,
-    proxyUrl,
-    store,
-    systemPrompt,
-    onUsage,
-    toolsDefs,
-    thinkingLevel,
-    workflowToolsConfig,
-    modelSelector,
-    contractsContext,
-    surfacePlanConfig,
-    mcpTools
-  ]);
-  React.useEffect(() => {
-    if (!conversationId || !chatServiceRef.current)
-      return;
-    const loadConversation = async () => {
-      if (!chatServiceRef.current)
-        return;
-      const conv = await chatServiceRef.current.getConversation(conversationId);
-      if (conv) {
-        setConversation(conv);
-        setMessages(conv.messages);
-      }
-    };
-    loadConversation().catch(console.error);
-  }, [conversationId]);
-  const sendMessage = React.useCallback(async (content, attachments, opts) => {
-    if (agentMode?.agent) {
-      setIsLoading(true);
-      setError(null);
-      abortControllerRef.current = new AbortController;
-      try {
-        if (!opts?.skipUserAppend) {
-          const userMessage = {
-            id: `msg_${Date.now()}`,
-            conversationId: conversationId ?? "",
-            role: "user",
-            content,
-            status: "completed",
-            createdAt: new Date,
-            updatedAt: new Date,
-            attachments
-          };
-          setMessages((prev) => [...prev, userMessage]);
-          onSend?.(userMessage);
-        }
-        const result = await agentMode.agent.generate({
-          prompt: content,
-          signal: abortControllerRef.current.signal
-        });
-        const toolCallsMap = new Map;
-        for (const tc of result.toolCalls ?? []) {
-          const tr = result.toolResults?.find((r) => r.toolCallId === tc.toolCallId);
-          toolCallsMap.set(tc.toolCallId, {
-            id: tc.toolCallId,
-            name: tc.toolName,
-            args: tc.args ?? {},
-            result: tr?.output,
-            status: "completed"
-          });
-        }
-        const assistantMessage = {
-          id: `msg_${Date.now()}_a`,
-          conversationId: conversationId ?? "",
-          role: "assistant",
-          content: result.text,
-          status: "completed",
-          createdAt: new Date,
-          updatedAt: new Date,
-          toolCalls: toolCallsMap.size ? Array.from(toolCallsMap.values()) : undefined,
-          usage: result.usage
-        };
-        setMessages((prev) => [...prev, assistantMessage]);
-        onResponse?.(assistantMessage);
-        onUsage?.(result.usage ?? { inputTokens: 0, outputTokens: 0 });
-        if (store && !conversationId) {
-          const conv = await store.create({
-            status: "active",
-            provider: "agent",
-            model: "agent",
-            messages: []
-          });
-          if (!opts?.skipUserAppend) {
-            await store.appendMessage(conv.id, {
-              role: "user",
-              content,
-              status: "completed",
-              attachments
-            });
-          }
-          await store.appendMessage(conv.id, {
-            role: "assistant",
-            content: result.text,
-            status: "completed",
-            toolCalls: assistantMessage.toolCalls,
-            usage: result.usage
-          });
-          const updated = await store.get(conv.id);
-          if (updated)
-            setConversation(updated);
-          setConversationId(conv.id);
-        }
-      } catch (err) {
-        setError(err instanceof Error ? err : new Error(String(err)));
-        onError?.(err instanceof Error ? err : new Error(String(err)));
-      } finally {
-        setIsLoading(false);
-      }
-      return;
-    }
-    if (!chatServiceRef.current) {
-      throw new Error("Chat service not initialized");
-    }
-    setIsLoading(true);
-    setError(null);
-    abortControllerRef.current = new AbortController;
-    try {
-      if (!opts?.skipUserAppend) {
-        const userMessage = {
-          id: `msg_${Date.now()}`,
-          conversationId: conversationId ?? "",
-          role: "user",
-          content,
-          status: "completed",
-          createdAt: new Date,
-          updatedAt: new Date,
-          attachments
-        };
-        setMessages((prev) => [...prev, userMessage]);
-        onSend?.(userMessage);
-      }
-      if (streaming) {
-        const result = await chatServiceRef.current.stream({
-          conversationId: conversationId ?? undefined,
-          content,
-          attachments,
-          skipUserAppend: opts?.skipUserAppend
-        });
-        if (!conversationId && !opts?.skipUserAppend) {
-          setConversationId(result.conversationId);
-        }
-        const assistantMessage = {
-          id: result.messageId,
-          conversationId: result.conversationId,
-          role: "assistant",
-          content: "",
-          status: "streaming",
-          createdAt: new Date,
-          updatedAt: new Date
-        };
-        setMessages((prev) => [...prev, assistantMessage]);
-        let fullContent = "";
-        let fullReasoning = "";
-        const toolCallsMap = new Map;
-        const sources = [];
-        for await (const chunk of result.stream) {
-          if (chunk.type === "text" && chunk.content) {
-            fullContent += chunk.content;
-            setMessages((prev) => prev.map((m) => m.id === result.messageId ? {
-              ...m,
-              content: fullContent,
-              reasoning: fullReasoning || undefined,
-              sources: sources.length ? sources : undefined,
-              toolCalls: toolCallsMap.size ? Array.from(toolCallsMap.values()) : undefined
-            } : m));
-          } else if (chunk.type === "reasoning" && chunk.content) {
-            fullReasoning += chunk.content;
-            setMessages((prev) => prev.map((m) => m.id === result.messageId ? { ...m, reasoning: fullReasoning } : m));
-          } else if (chunk.type === "source" && chunk.source) {
-            sources.push(chunk.source);
-            setMessages((prev) => prev.map((m) => m.id === result.messageId ? { ...m, sources: [...sources] } : m));
-          } else if (chunk.type === "tool_call" && chunk.toolCall) {
-            const tc = chunk.toolCall;
-            const chatTc = {
-              id: tc.id,
-              name: tc.name,
-              args: tc.args,
-              status: "running"
-            };
-            toolCallsMap.set(tc.id, chatTc);
-            setMessages((prev) => prev.map((m) => m.id === result.messageId ? { ...m, toolCalls: Array.from(toolCallsMap.values()) } : m));
-          } else if (chunk.type === "tool_result" && chunk.toolResult) {
-            const tr = chunk.toolResult;
-            const tc = toolCallsMap.get(tr.toolCallId);
-            if (tc) {
-              tc.result = tr.result;
-              tc.status = "completed";
-            }
-            setMessages((prev) => prev.map((m) => m.id === result.messageId ? { ...m, toolCalls: Array.from(toolCallsMap.values()) } : m));
-          } else if (chunk.type === "done") {
-            setMessages((prev) => prev.map((m) => m.id === result.messageId ? {
-              ...m,
-              content: fullContent,
-              reasoning: fullReasoning || undefined,
-              sources: sources.length ? sources : undefined,
-              toolCalls: toolCallsMap.size ? Array.from(toolCallsMap.values()) : undefined,
-              status: "completed",
-              usage: chunk.usage,
-              updatedAt: new Date
-            } : m));
-            onResponse?.(messages.find((m) => m.id === result.messageId) ?? assistantMessage);
-          } else if (chunk.type === "error") {
-            setMessages((prev) => prev.map((m) => m.id === result.messageId ? {
-              ...m,
-              status: "error",
-              error: chunk.error,
-              updatedAt: new Date
-            } : m));
-            if (chunk.error) {
-              const err = new Error(chunk.error.message);
-              setError(err);
-              onError?.(err);
-            }
-          }
-        }
-      } else {
-        const result = await chatServiceRef.current.send({
-          conversationId: conversationId ?? undefined,
-          content,
-          attachments,
-          skipUserAppend: opts?.skipUserAppend
-        });
-        setConversation(result.conversation);
-        setMessages(result.conversation.messages);
-        if (!conversationId) {
-          setConversationId(result.conversation.id);
-        }
-        onResponse?.(result.message);
-      }
-    } catch (err) {
-      const error2 = err instanceof Error ? err : new Error(String(err));
-      setError(error2);
-      onError?.(error2);
-    } finally {
-      setIsLoading(false);
-      abortControllerRef.current = null;
-    }
-  }, [
-    conversationId,
-    streaming,
-    onSend,
-    onResponse,
-    onError,
-    onUsage,
-    messages,
-    agentMode,
-    store
-  ]);
-  const clearConversation = React.useCallback(() => {
-    setMessages([]);
-    setConversation(null);
-    setConversationId(null);
-    setError(null);
-  }, []);
-  const regenerate = React.useCallback(async () => {
-    let lastUserMessageIndex = -1;
-    for (let i = messages.length - 1;i >= 0; i--) {
-      const m = messages[i];
-      if (m?.role === "user") {
-        lastUserMessageIndex = i;
-        break;
-      }
-    }
-    if (lastUserMessageIndex === -1)
-      return;
-    const lastUserMessage = messages[lastUserMessageIndex];
-    if (!lastUserMessage)
-      return;
-    setMessages((prev) => prev.slice(0, lastUserMessageIndex + 1));
-    await sendMessage(lastUserMessage.content, lastUserMessage.attachments);
-  }, [messages, sendMessage]);
-  const stop = React.useCallback(() => {
-    abortControllerRef.current?.abort();
-    setIsLoading(false);
-  }, []);
-  const createNewConversation = clearConversation;
-  const editMessage = React.useCallback(async (messageId, newContent) => {
-    if (!chatServiceRef.current || !conversationId)
-      return;
-    const msg = messages.find((m) => m.id === messageId);
-    if (!msg || msg.role !== "user")
-      return;
-    await chatServiceRef.current.updateMessage(conversationId, messageId, {
-      content: newContent
-    });
-    const truncated = await chatServiceRef.current.truncateAfter(conversationId, messageId);
-    if (truncated) {
-      setMessages(truncated.messages);
-    }
-    await sendMessage(newContent, undefined, { skipUserAppend: true });
-  }, [conversationId, messages, sendMessage]);
-  const forkConversation = React.useCallback(async (upToMessageId) => {
-    if (!chatServiceRef.current)
-      return null;
-    const idToFork = conversationId ?? conversation?.id;
-    if (!idToFork)
-      return null;
-    try {
-      const forked = await chatServiceRef.current.forkConversation(idToFork, upToMessageId);
-      setConversationId(forked.id);
-      setConversation(forked);
-      setMessages(forked.messages);
-      return forked.id;
-    } catch {
-      return null;
-    }
-  }, [conversationId, conversation]);
-  const updateConversationFn = React.useCallback(async (updates) => {
-    if (!chatServiceRef.current || !conversationId)
-      return null;
-    const updated = await chatServiceRef.current.updateConversation(conversationId, updates);
-    if (updated)
-      setConversation(updated);
-    return updated;
-  }, [conversationId]);
-  const addToolApprovalResponse = React.useCallback((_toolCallId, _result) => {
-    throw new Error(`addToolApprovalResponse: Tool approval requires server route with toUIMessageStreamResponse. ` + `Use createChatRoute and @ai-sdk/react useChat for tools with requireApproval.`);
-  }, []);
-  const hasApprovalTools = toolsDefs?.some((t) => t.requireApproval) ?? false;
-  return {
-    messages,
-    conversation,
-    isLoading,
-    error,
-    sendMessage,
-    clearConversation,
-    setConversationId,
-    regenerate,
-    stop,
-    createNewConversation,
-    editMessage,
-    forkConversation,
-    updateConversation: updateConversationFn,
-    ...hasApprovalTools && { addToolApprovalResponse }
-  };
-}
-// src/presentation/hooks/useConversations.ts
-import * as React2 from "react";
-"use client";
-function useConversations(options) {
-  const { store, projectId, tags, limit = 50 } = options;
-  const [conversations, setConversations] = React2.useState([]);
-  const [isLoading, setIsLoading] = React2.useState(true);
-  const refresh = React2.useCallback(async () => {
-    setIsLoading(true);
-    try {
-      const list = await store.list({
-        status: "active",
-        projectId,
-        tags,
-        limit
-      });
-      setConversations(list);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [store, projectId, tags, limit]);
-  React2.useEffect(() => {
-    refresh();
-  }, [refresh]);
-  const deleteConversation = React2.useCallback(async (id) => {
-    const ok = await store.delete(id);
-    if (ok) {
-      setConversations((prev) => prev.filter((c) => c.id !== id));
-    }
-    return ok;
-  }, [store]);
-  return {
-    conversations,
-    isLoading,
-    refresh,
-    deleteConversation
-  };
-}
-// src/presentation/hooks/useMessageSelection.ts
-import * as React3 from "react";
-"use client";
-function useMessageSelection(messageIds) {
-  const [selectedIds, setSelectedIds] = React3.useState(() => new Set);
-  const idSet = React3.useMemo(() => new Set(messageIds), [messageIds.join(",")]);
-  React3.useEffect(() => {
-    setSelectedIds((prev) => {
-      const next = new Set;
-      for (const id of prev) {
-        if (idSet.has(id))
-          next.add(id);
-      }
-      return next.size === prev.size ? prev : next;
-    });
-  }, [idSet]);
-  const toggle = React3.useCallback((id) => {
-    setSelectedIds((prev) => {
-      const next = new Set(prev);
-      if (next.has(id))
-        next.delete(id);
-      else
-        next.add(id);
-      return next;
-    });
-  }, []);
-  const selectAll = React3.useCallback(() => {
-    setSelectedIds(new Set(messageIds));
-  }, [messageIds.join(",")]);
-  const clearSelection = React3.useCallback(() => {
-    setSelectedIds(new Set);
-  }, []);
-  const isSelected = React3.useCallback((id) => selectedIds.has(id), [selectedIds]);
-  const selectedCount = selectedIds.size;
-  return {
-    selectedIds,
-    toggle,
-    selectAll,
-    clearSelection,
-    isSelected,
-    selectedCount
-  };
-}
-// src/presentation/hooks/useProviders.tsx
-import {
-  getAvailableProviders,
-  getModelsForProvider
-} from "@contractspec/lib.ai-providers";
-import * as React4 from "react";
-"use client";
-function useProviders() {
-  const [providers, setProviders] = React4.useState([]);
-  const [isLoading, setIsLoading] = React4.useState(true);
-  const loadProviders = React4.useCallback(async () => {
-    setIsLoading(true);
-    try {
-      const available = getAvailableProviders();
-      const providersWithModels = available.map((p) => ({
-        ...p,
-        models: getModelsForProvider(p.provider)
-      }));
-      setProviders(providersWithModels);
-    } catch (error) {
-      console.error("Failed to load providers:", error);
-    } finally {
-      setIsLoading(false);
-    }
-  }, []);
-  React4.useEffect(() => {
-    loadProviders();
-  }, [loadProviders]);
-  const availableProviders = React4.useMemo(() => providers.filter((p) => p.available), [providers]);
-  const isAvailable = React4.useCallback((provider) => providers.some((p) => p.provider === provider && p.available), [providers]);
-  const getModelsCallback = React4.useCallback((provider) => providers.find((p) => p.provider === provider)?.models ?? [], [providers]);
-  return {
-    providers,
-    availableProviders,
-    isAvailable,
-    getModels: getModelsCallback,
-    isLoading,
-    refresh: loadProviders
-  };
-}
-export {
-  useProviders,
-  useMessageSelection,
-  useConversations,
-  useCompletion,
-  useChat
-};
+[Attachment: ${q.name}]`}).join("");j+=H}J.push({role:"user",content:j})}else if(G.role==="assistant")if(G.toolCalls?.length)J.push({role:"assistant",content:G.content||"",toolCalls:G.toolCalls.map((j)=>({type:"tool-call",toolCallId:j.id,toolName:j.name,args:j.args}))}),J.push({role:"tool",content:G.toolCalls.map((j)=>({type:"tool-result",toolCallId:j.id,toolName:j.name,output:j.result}))});else J.push({role:"assistant",content:G.content})}return J}}function CZ(X){return new ZX(X)}function eX(X){let Z={};for(let $ of X)Z[$.name]=sX({description:$.description??$.name,inputSchema:oX.object({}).passthrough(),execute:async()=>({})});return Z}function XZ(X={}){let{provider:Z="openai",mode:$="byok",model:J,apiKey:Y,proxyUrl:G,conversationId:j,store:H,systemPrompt:q,streaming:Q=!0,onSend:_,onResponse:A,onError:N,onUsage:k,tools:P,thinkingLevel:I,workflowToolsConfig:h,modelSelector:U,contractsContext:W,surfacePlanConfig:f,mcpServers:g,agentMode:$X}=X,[m,x]=E.useState([]),[VX,t]=E.useState(null),JX=E.useRef(null),[YX,p]=E.useState(null),[FX,a]=E.useState(!1),[AX,c]=E.useState(null),[w,i]=E.useState(j??null),r=E.useRef(null),T=E.useRef(null);E.useEffect(()=>{if(!g?.length){t(null);return}let D=!1;return import("@contractspec/lib.ai-agent/tools/mcp-client.browser").then(({createMcpToolsets:F})=>{F(g).then(({tools:L,cleanup:V})=>{if(!D)t(L),JX.current=V;else V().catch(()=>{return})}).catch(()=>{if(!D)t(null)})}),()=>{D=!0;let F=JX.current;if(JX.current=null,F)F().catch(()=>{return});t(null)}},[g]),E.useEffect(()=>{let D=tX({provider:Z,model:J,apiKey:Y,proxyUrl:G});T.current=new ZX({provider:D,store:H,systemPrompt:q,onUsage:k,tools:P?.length?eX(P):void 0,thinkingLevel:I,workflowToolsConfig:h,modelSelector:U,contractsContext:W,surfacePlanConfig:f,mcpTools:VX})},[Z,$,J,Y,G,H,q,k,P,I,h,U,W,f,VX]),E.useEffect(()=>{if(!w||!T.current)return;(async()=>{if(!T.current)return;let F=await T.current.getConversation(w);if(F)p(F),x(F.messages)})().catch(console.error)},[w]);let n=E.useCallback(async(D,F,L)=>{if($X?.agent){a(!0),c(null),r.current=new AbortController;try{if(!L?.skipUserAppend){let R={id:`msg_${Date.now()}`,conversationId:w??"",role:"user",content:D,status:"completed",createdAt:new Date,updatedAt:new Date,attachments:F};x((b)=>[...b,R]),_?.(R)}let V=await $X.agent.generate({prompt:D,signal:r.current.signal}),S=new Map;for(let R of V.toolCalls??[]){let b=V.toolResults?.find((u)=>u.toolCallId===R.toolCallId);S.set(R.toolCallId,{id:R.toolCallId,name:R.toolName,args:R.args??{},result:b?.output,status:"completed"})}let d={id:`msg_${Date.now()}_a`,conversationId:w??"",role:"assistant",content:V.text,status:"completed",createdAt:new Date,updatedAt:new Date,toolCalls:S.size?Array.from(S.values()):void 0,usage:V.usage};if(x((R)=>[...R,d]),A?.(d),k?.(V.usage??{inputTokens:0,outputTokens:0}),H&&!w){let R=await H.create({status:"active",provider:"agent",model:"agent",messages:[]});if(!L?.skipUserAppend)await H.appendMessage(R.id,{role:"user",content:D,status:"completed",attachments:F});await H.appendMessage(R.id,{role:"assistant",content:V.text,status:"completed",toolCalls:d.toolCalls,usage:V.usage});let b=await H.get(R.id);if(b)p(b);i(R.id)}}catch(V){c(V instanceof Error?V:Error(String(V))),N?.(V instanceof Error?V:Error(String(V)))}finally{a(!1)}return}if(!T.current)throw Error("Chat service not initialized");a(!0),c(null),r.current=new AbortController;try{if(!L?.skipUserAppend){let V={id:`msg_${Date.now()}`,conversationId:w??"",role:"user",content:D,status:"completed",createdAt:new Date,updatedAt:new Date,attachments:F};x((S)=>[...S,V]),_?.(V)}if(Q){let V=await T.current.stream({conversationId:w??void 0,content:D,attachments:F,skipUserAppend:L?.skipUserAppend});if(!w&&!L?.skipUserAppend)i(V.conversationId);let S={id:V.messageId,conversationId:V.conversationId,role:"assistant",content:"",status:"streaming",createdAt:new Date,updatedAt:new Date};x((y)=>[...y,S]);let d="",R="",b=new Map,u=[];for await(let y of V.stream)if(y.type==="text"&&y.content)d+=y.content,x((z)=>z.map((O)=>O.id===V.messageId?{...O,content:d,reasoning:R||void 0,sources:u.length?u:void 0,toolCalls:b.size?Array.from(b.values()):void 0}:O));else if(y.type==="reasoning"&&y.content)R+=y.content,x((z)=>z.map((O)=>O.id===V.messageId?{...O,reasoning:R}:O));else if(y.type==="source"&&y.source)u.push(y.source),x((z)=>z.map((O)=>O.id===V.messageId?{...O,sources:[...u]}:O));else if(y.type==="tool_call"&&y.toolCall){let z=y.toolCall,O={id:z.id,name:z.name,args:z.args,status:"running"};b.set(z.id,O),x((jX)=>jX.map((l)=>l.id===V.messageId?{...l,toolCalls:Array.from(b.values())}:l))}else if(y.type==="tool_result"&&y.toolResult){let z=y.toolResult,O=b.get(z.toolCallId);if(O)O.result=z.result,O.status="completed";x((jX)=>jX.map((l)=>l.id===V.messageId?{...l,toolCalls:Array.from(b.values())}:l))}else if(y.type==="done")x((z)=>z.map((O)=>O.id===V.messageId?{...O,content:d,reasoning:R||void 0,sources:u.length?u:void 0,toolCalls:b.size?Array.from(b.values()):void 0,status:"completed",usage:y.usage,updatedAt:new Date}:O)),A?.(m.find((z)=>z.id===V.messageId)??S);else if(y.type==="error"){if(x((z)=>z.map((O)=>O.id===V.messageId?{...O,status:"error",error:y.error,updatedAt:new Date}:O)),y.error){let z=Error(y.error.message);c(z),N?.(z)}}}else{let V=await T.current.send({conversationId:w??void 0,content:D,attachments:F,skipUserAppend:L?.skipUserAppend});if(p(V.conversation),x(V.conversation.messages),!w)i(V.conversation.id);A?.(V.message)}}catch(V){let S=V instanceof Error?V:Error(String(V));c(S),N?.(S)}finally{a(!1),r.current=null}},[w,Q,_,A,N,k,m,$X,H]),HX=E.useCallback(()=>{x([]),p(null),i(null),c(null)},[]),KX=E.useCallback(async()=>{let D=-1;for(let L=m.length-1;L>=0;L--)if(m[L]?.role==="user"){D=L;break}if(D===-1)return;let F=m[D];if(!F)return;x((L)=>L.slice(0,D+1)),await n(F.content,F.attachments)},[m,n]),OX=E.useCallback(()=>{r.current?.abort(),a(!1)},[]),EX=HX,LX=E.useCallback(async(D,F)=>{if(!T.current||!w)return;let L=m.find((S)=>S.id===D);if(!L||L.role!=="user")return;await T.current.updateMessage(w,D,{content:F});let V=await T.current.truncateAfter(w,D);if(V)x(V.messages);await n(F,void 0,{skipUserAppend:!0})},[w,m,n]),yX=E.useCallback(async(D)=>{if(!T.current)return null;let F=w??YX?.id;if(!F)return null;try{let L=await T.current.forkConversation(F,D);return i(L.id),p(L),x(L.messages),L.id}catch{return null}},[w,YX]),zX=E.useCallback(async(D)=>{if(!T.current||!w)return null;let F=await T.current.updateConversation(w,D);if(F)p(F);return F},[w]),wX=E.useCallback((D,F)=>{throw Error("addToolApprovalResponse: Tool approval requires server route with toUIMessageStreamResponse. Use createChatRoute and @ai-sdk/react useChat for tools with requireApproval.")},[]),RX=P?.some((D)=>D.requireApproval)??!1;return{messages:m,conversation:YX,isLoading:FX,error:AX,sendMessage:n,clearConversation:HX,setConversationId:i,regenerate:KX,stop:OX,createNewConversation:EX,editMessage:LX,forkConversation:yX,updateConversation:zX,...RX&&{addToolApprovalResponse:wX}}}import*as v from"react";function ZZ(X){let{store:Z,projectId:$,tags:J,limit:Y=50}=X,[G,j]=v.useState([]),[H,q]=v.useState(!0),Q=v.useCallback(async()=>{q(!0);try{let A=await Z.list({status:"active",projectId:$,tags:J,limit:Y});j(A)}finally{q(!1)}},[Z,$,J,Y]);v.useEffect(()=>{Q()},[Q]);let _=v.useCallback(async(A)=>{let N=await Z.delete(A);if(N)j((k)=>k.filter((P)=>P.id!==A));return N},[Z]);return{conversations:G,isLoading:H,refresh:Q,deleteConversation:_}}import*as C from"react";function $Z(X){let[Z,$]=C.useState(()=>new Set),J=C.useMemo(()=>new Set(X),[X.join(",")]);C.useEffect(()=>{$((Q)=>{let _=new Set;for(let A of Q)if(J.has(A))_.add(A);return _.size===Q.size?Q:_})},[J]);let Y=C.useCallback((Q)=>{$((_)=>{let A=new Set(_);if(A.has(Q))A.delete(Q);else A.add(Q);return A})},[]),G=C.useCallback(()=>{$(new Set(X))},[X.join(",")]),j=C.useCallback(()=>{$(new Set)},[]),H=C.useCallback((Q)=>Z.has(Q),[Z]),q=Z.size;return{selectedIds:Z,toggle:Y,selectAll:G,clearSelection:j,isSelected:H,selectedCount:q}}import{getAvailableProviders as JZ,getModelsForProvider as YZ}from"@contractspec/lib.ai-providers";import*as M from"react";function jZ(){let[X,Z]=M.useState([]),[$,J]=M.useState(!0),Y=M.useCallback(async()=>{J(!0);try{let Q=JZ().map((_)=>({..._,models:YZ(_.provider)}));Z(Q)}catch(q){console.error("Failed to load providers:",q)}finally{J(!1)}},[]);M.useEffect(()=>{Y()},[Y]);let G=M.useMemo(()=>X.filter((q)=>q.available),[X]),j=M.useCallback((q)=>X.some((Q)=>Q.provider===q&&Q.available),[X]),H=M.useCallback((q)=>X.find((Q)=>Q.provider===q)?.models??[],[X]);return{providers:X,availableProviders:G,isAvailable:j,getModels:H,isLoading:$,refresh:Y}}export{jZ as useProviders,$Z as useMessageSelection,ZZ as useConversations,aZ as useCompletion,XZ as useChat};