@contractspec/module.ai-chat 4.0.3 → 4.1.0

package/dist/core/index.js

@@ -77,11 +77,65 @@ class InMemoryConversationStore {
     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 = [];
@@ -108,6 +162,505 @@ function createInMemoryConversationStore() {
 }
 // src/core/chat-service.ts
 import { generateText, streamText } from "ai";
+
+// 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 { tool } from "ai";
+import { z } from "zod";
+import {
+  WorkflowComposer,
+  validateExtension
+} from "@contractspec/lib.workflow-composer";
+var StepTypeSchema = z.enum(["human", "automation", "decision"]);
+var StepActionSchema = z.object({
+  operation: z.object({
+    name: z.string(),
+    version: z.number()
+  }).optional(),
+  form: z.object({
+    key: z.string(),
+    version: z.number()
+  }).optional()
+}).optional();
+var StepSchema = z.object({
+  id: z.string(),
+  type: StepTypeSchema,
+  label: z.string(),
+  description: z.string().optional(),
+  action: StepActionSchema
+});
+var StepInjectionSchema = z.object({
+  after: z.string().optional(),
+  before: z.string().optional(),
+  inject: StepSchema,
+  transitionTo: z.string().optional(),
+  transitionFrom: z.string().optional(),
+  when: z.string().optional()
+});
+var WorkflowExtensionInputSchema = z.object({
+  workflow: z.string(),
+  tenantId: z.string().optional(),
+  role: z.string().optional(),
+  priority: z.number().optional(),
+  customSteps: z.array(StepInjectionSchema).optional(),
+  hiddenSteps: z.array(z.string()).optional()
+});
+function createWorkflowTools(config) {
+  const { baseWorkflows, composer } = config;
+  const baseByKey = new Map(baseWorkflows.map((b) => [b.meta.key, b]));
+  const createWorkflowExtensionTool = tool({
+    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 = z.object({
+    workflowKey: z.string().describe("Base workflow meta.key"),
+    tenantId: z.string().optional(),
+    role: z.string().optional(),
+    extensions: z.array(WorkflowExtensionInputSchema).optional().describe("Extensions to register before composing")
+  });
+  const composeWorkflowTool = tool({
+    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 = z.object({
+    workflowKey: z.string().describe("Workflow meta.key"),
+    composedSteps: z.array(z.object({
+      id: z.string(),
+      type: z.enum(["human", "automation", "decision"]),
+      label: z.string(),
+      description: z.string().optional()
+    })).optional().describe("Steps to include; if omitted, uses the base workflow")
+  });
+  const generateWorkflowSpecCodeTool = tool({
+    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)}',` : ""}
+    }`).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';
+
+/**
+ * Workflow: ${base.meta.key}
+ * Generated via AI chat workflow tools.
+ */
+export const ${specVarName}: WorkflowSpec = {
+  meta: {
+    key: '${base.meta.key}',
+    version: '${String(base.meta.version)}',
+    title: '${escapeString(meta.title ?? base.meta.key)}',
+    description: '${escapeString(meta.description ?? "")}',
+  },
+  definition: {
+    entryStepId: '${base.definition.entryStepId ?? base.definition.steps[0]?.id ?? ""}',
+    steps: [
+${stepsCode}
+    ],
+    transitions: ${transitionsJson},
+  },
+};
+`;
+      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/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/agent-tools-adapter.ts
+import { tool as tool2 } from "ai";
+import { z as z2 } from "zod";
+function getInputSchema(_schema) {
+  return z2.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] = tool2({
+      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/surface-planner-tools.ts
+import { tool as tool3 } from "ai";
+import { z as z3 } from "zod";
+import { validatePatchProposal } from "@contractspec/lib.surface-runtime/spec/validate-surface-patch";
+import { buildSurfacePatchProposal } from "@contractspec/lib.surface-runtime/runtime/planner-tools";
+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 = z3.object({
+  proposalId: z3.string().describe("Unique proposal identifier"),
+  ops: z3.array(z3.object({
+    op: z3.enum([
+      "insert-node",
+      "replace-node",
+      "remove-node",
+      "move-node",
+      "resize-panel",
+      "set-layout",
+      "reveal-field",
+      "hide-field",
+      "promote-action",
+      "set-focus"
+    ]),
+    slotId: z3.string().optional(),
+    nodeId: z3.string().optional(),
+    toSlotId: z3.string().optional(),
+    index: z3.number().optional(),
+    node: z3.object({
+      nodeId: z3.string(),
+      kind: z3.string(),
+      title: z3.string().optional(),
+      props: z3.record(z3.string(), z3.unknown()).optional(),
+      children: z3.array(z3.unknown()).optional()
+    }).optional(),
+    persistKey: z3.string().optional(),
+    sizes: z3.array(z3.number()).optional(),
+    layoutId: z3.string().optional(),
+    fieldId: z3.string().optional(),
+    actionId: z3.string().optional(),
+    placement: z3.enum(["header", "inline", "context", "assistant"]).optional(),
+    targetId: z3.string().optional()
+  }))
+});
+function createSurfacePlannerTools(config) {
+  const { plan, constraints, onPatchProposal } = config;
+  const resolvedConstraints = constraints ?? deriveConstraints(plan);
+  const proposePatchTool = tool3({
+    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/chat-service.ts
+import { compilePlannerPrompt } from "@contractspec/lib.surface-runtime/runtime/planner-prompt";
 var DEFAULT_SYSTEM_PROMPT = `You are ContractSpec AI, an expert coding assistant specialized in ContractSpec development.
 
 Your capabilities:
@@ -122,6 +675,9 @@ Guidelines:
 - 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.`;
 
 class ChatService {
   provider;
@@ -131,19 +687,93 @@ class ChatService {
   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 = config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+    this.systemPrompt = this.buildSystemPrompt(config);
     this.maxHistoryMessages = config.maxHistoryMessages ?? 20;
     this.onUsage = config.onUsage;
-    this.tools = config.tools;
-    this.sendReasoning = config.sendReasoning ?? false;
+    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 += `
+
+` + 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) {
@@ -161,20 +791,25 @@ class ChatService {
         workspacePath: this.context?.workspacePath
       });
     }
-    await this.store.appendMessage(conversation.id, {
-      role: "user",
-      content: options.content,
-      status: "completed",
-      attachments: options.attachments
-    });
+    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 = this.provider.getModel();
+    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
+        tools: this.tools,
+        providerOptions: Object.keys(providerOptions).length > 0 ? providerOptions : undefined
       });
       const assistantMessage = await this.store.appendMessage(conversation.id, {
         role: "assistant",
@@ -219,23 +854,27 @@ class ChatService {
         workspacePath: this.context?.workspacePath
       });
     }
-    await this.store.appendMessage(conversation.id, {
-      role: "user",
-      content: options.content,
-      status: "completed",
-      attachments: options.attachments
-    });
+    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 = this.provider.getModel();
+    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 = "";
@@ -246,7 +885,8 @@ class ChatService {
           model,
           messages,
           system: systemPrompt,
-          tools
+          tools,
+          providerOptions: Object.keys(streamProviderOptions).length > 0 ? streamProviderOptions : undefined
         });
         for await (const part of result.fullStream) {
           if (part.type === "text-delta") {
@@ -361,6 +1001,18 @@ class ChatService {
       ...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);
   }
@@ -429,7 +1081,12 @@ import {
 } from "ai";
 var DEFAULT_SYSTEM_PROMPT2 = `You are a helpful AI assistant.`;
 function createChatRoute(options) {
-  const { provider, systemPrompt = DEFAULT_SYSTEM_PROMPT2, tools } = options;
+  const {
+    provider,
+    systemPrompt = DEFAULT_SYSTEM_PROMPT2,
+    tools,
+    thinkingLevel: defaultThinkingLevel
+  } = options;
   return async (req) => {
     if (req.method !== "POST") {
       return new Response("Method not allowed", { status: 405 });
@@ -444,12 +1101,15 @@ function createChatRoute(options) {
     if (!Array.isArray(messages) || messages.length === 0) {
       return new Response("messages array required", { status: 400 });
     }
+    const thinkingLevel = body.thinkingLevel ?? defaultThinkingLevel;
+    const providerOptions = getProviderOptions(thinkingLevel, provider.name);
     const model = provider.getModel();
     const result = streamText2({
       model,
       messages: await convertToModelMessages(messages),
       system: systemPrompt,
-      tools
+      tools,
+      providerOptions: Object.keys(providerOptions).length > 0 ? providerOptions : undefined
     });
     return result.toUIMessageStreamResponse();
   };
@@ -481,11 +1141,468 @@ function createCompletionRoute(options) {
     return result.toTextStreamResponse();
   };
 }
+// src/core/export-formatters.ts
+function formatTimestamp(date) {
+  return date.toLocaleTimeString([], {
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+function toIsoString(date) {
+  return date.toISOString();
+}
+function messageToJsonSerializable(msg) {
+  return {
+    id: msg.id,
+    conversationId: msg.conversationId,
+    role: msg.role,
+    content: msg.content,
+    status: msg.status,
+    createdAt: toIsoString(msg.createdAt),
+    updatedAt: toIsoString(msg.updatedAt),
+    ...msg.attachments && { attachments: msg.attachments },
+    ...msg.codeBlocks && { codeBlocks: msg.codeBlocks },
+    ...msg.toolCalls && { toolCalls: msg.toolCalls },
+    ...msg.sources && { sources: msg.sources },
+    ...msg.reasoning && { reasoning: msg.reasoning },
+    ...msg.usage && { usage: msg.usage },
+    ...msg.error && { error: msg.error },
+    ...msg.metadata && { metadata: msg.metadata }
+  };
+}
+function formatSourcesMarkdown(sources) {
+  if (sources.length === 0)
+    return "";
+  return `
+
+**Sources:**
+` + sources.map((s) => `- [${s.title}](${s.url ?? "#"})`).join(`
+`);
+}
+function formatSourcesTxt(sources) {
+  if (sources.length === 0)
+    return "";
+  return `
+
+Sources:
+` + sources.map((s) => `- ${s.title}${s.url ? ` - ${s.url}` : ""}`).join(`
+`);
+}
+function formatToolCallsMarkdown(toolCalls) {
+  if (toolCalls.length === 0)
+    return "";
+  return `
+
+**Tool calls:**
+` + toolCalls.map((tc) => `**${tc.name}** (${tc.status})
+\`\`\`json
+${JSON.stringify(tc.args, null, 2)}
+\`\`\`` + (tc.result !== undefined ? `
+Output:
+\`\`\`json
+${typeof tc.result === "object" ? JSON.stringify(tc.result, null, 2) : String(tc.result)}
+\`\`\`` : "") + (tc.error ? `
+Error: ${tc.error}` : "")).join(`
+
+`);
+}
+function formatToolCallsTxt(toolCalls) {
+  if (toolCalls.length === 0)
+    return "";
+  return `
+
+Tool calls:
+` + toolCalls.map((tc) => `- ${tc.name} (${tc.status}): ${JSON.stringify(tc.args)}` + (tc.result !== undefined ? ` -> ${typeof tc.result === "object" ? JSON.stringify(tc.result) : String(tc.result)}` : "") + (tc.error ? ` [Error: ${tc.error}]` : "")).join(`
+`);
+}
+function formatUsage(usage) {
+  const total = usage.inputTokens + usage.outputTokens;
+  return ` (${total} tokens)`;
+}
+function formatMessagesAsMarkdown(messages) {
+  const parts = [];
+  for (const msg of messages) {
+    const roleLabel = msg.role === "user" ? "User" : msg.role === "assistant" ? "Assistant" : "System";
+    const header = `## ${roleLabel}`;
+    const timestamp = `*${formatTimestamp(msg.createdAt)}*`;
+    const usageSuffix = msg.usage ? formatUsage(msg.usage) : "";
+    const meta = `${timestamp}${usageSuffix}
+
+`;
+    let body = msg.content;
+    if (msg.error) {
+      body += `
+
+**Error:** ${msg.error.code} - ${msg.error.message}`;
+    }
+    if (msg.reasoning) {
+      body += `
+
+> **Reasoning:**
+> ${msg.reasoning.replace(/\n/g, `
+> `)}`;
+    }
+    body += formatSourcesMarkdown(msg.sources ?? []);
+    body += formatToolCallsMarkdown(msg.toolCalls ?? []);
+    parts.push(`${header}
+
+${meta}${body}`);
+  }
+  return parts.join(`
+
+---
+
+`);
+}
+function formatMessagesAsTxt(messages) {
+  const parts = [];
+  for (const msg of messages) {
+    const roleLabel = msg.role === "user" ? "User" : msg.role === "assistant" ? "Assistant" : "System";
+    const timestamp = `(${formatTimestamp(msg.createdAt)})`;
+    const usageSuffix = msg.usage ? formatUsage(msg.usage) : "";
+    const header = `[${roleLabel}] ${timestamp}${usageSuffix}
+
+`;
+    let body = msg.content;
+    if (msg.error) {
+      body += `
+
+Error: ${msg.error.code} - ${msg.error.message}`;
+    }
+    if (msg.reasoning) {
+      body += `
+
+Reasoning: ${msg.reasoning}`;
+    }
+    body += formatSourcesTxt(msg.sources ?? []);
+    body += formatToolCallsTxt(msg.toolCalls ?? []);
+    parts.push(`${header}${body}`);
+  }
+  return parts.join(`
+
+---
+
+`);
+}
+function formatMessagesAsJson(messages, conversation) {
+  const payload = {
+    messages: messages.map(messageToJsonSerializable)
+  };
+  if (conversation) {
+    payload.conversation = {
+      id: conversation.id,
+      title: conversation.title,
+      status: conversation.status,
+      createdAt: toIsoString(conversation.createdAt),
+      updatedAt: toIsoString(conversation.updatedAt),
+      provider: conversation.provider,
+      model: conversation.model,
+      workspacePath: conversation.workspacePath,
+      contextFiles: conversation.contextFiles,
+      summary: conversation.summary,
+      metadata: conversation.metadata
+    };
+  }
+  return JSON.stringify(payload, null, 2);
+}
+function getExportFilename(format, conversation) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const base = conversation?.title ? conversation.title.replace(/[^a-zA-Z0-9-_]/g, "_").slice(0, 40) : "chat-export";
+  const ext = format === "markdown" ? "md" : format === "txt" ? "txt" : "json";
+  return `${base}-${timestamp}.${ext}`;
+}
+var MIME_TYPES = {
+  markdown: "text/markdown",
+  txt: "text/plain",
+  json: "application/json"
+};
+function downloadAsFile(content, filename, mimeType) {
+  const blob = new Blob([content], { type: mimeType });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(url);
+}
+function exportToFile(messages, format, conversation) {
+  let content;
+  if (format === "markdown") {
+    content = formatMessagesAsMarkdown(messages);
+  } else if (format === "txt") {
+    content = formatMessagesAsTxt(messages);
+  } else {
+    content = formatMessagesAsJson(messages, conversation);
+  }
+  const filename = getExportFilename(format, conversation);
+  const mimeType = MIME_TYPES[format];
+  downloadAsFile(content, filename, mimeType);
+}
+// src/core/local-storage-conversation-store.ts
+var DEFAULT_KEY = "contractspec:ai-chat:conversations";
+function generateId2(prefix) {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+function toSerializable(conv) {
+  return {
+    ...conv,
+    createdAt: conv.createdAt.toISOString(),
+    updatedAt: conv.updatedAt.toISOString(),
+    messages: conv.messages.map((m) => ({
+      ...m,
+      createdAt: m.createdAt.toISOString(),
+      updatedAt: m.updatedAt.toISOString()
+    }))
+  };
+}
+function fromSerializable(raw) {
+  const messages = raw.messages?.map((m) => ({
+    ...m,
+    createdAt: new Date(m.createdAt),
+    updatedAt: new Date(m.updatedAt)
+  })) ?? [];
+  return {
+    ...raw,
+    createdAt: new Date(raw.createdAt),
+    updatedAt: new Date(raw.updatedAt),
+    messages
+  };
+}
+function loadAll(key) {
+  if (typeof window === "undefined")
+    return new Map;
+  try {
+    const raw = window.localStorage.getItem(key);
+    if (!raw)
+      return new Map;
+    const arr = JSON.parse(raw);
+    const map = new Map;
+    for (const item of arr) {
+      const conv = fromSerializable(item);
+      map.set(conv.id, conv);
+    }
+    return map;
+  } catch {
+    return new Map;
+  }
+}
+function saveAll(key, map) {
+  if (typeof window === "undefined")
+    return;
+  try {
+    const arr = Array.from(map.values()).map(toSerializable);
+    window.localStorage.setItem(key, JSON.stringify(arr));
+  } catch {}
+}
+
+class LocalStorageConversationStore {
+  key;
+  cache = null;
+  constructor(storageKey = DEFAULT_KEY) {
+    this.key = storageKey;
+  }
+  getMap() {
+    if (!this.cache) {
+      this.cache = loadAll(this.key);
+    }
+    return this.cache;
+  }
+  persist() {
+    saveAll(this.key, this.getMap());
+  }
+  async get(conversationId) {
+    return this.getMap().get(conversationId) ?? null;
+  }
+  async create(conversation) {
+    const now = new Date;
+    const full = {
+      ...conversation,
+      id: generateId2("conv"),
+      createdAt: now,
+      updatedAt: now
+    };
+    this.getMap().set(full.id, full);
+    this.persist();
+    return full;
+  }
+  async update(conversationId, updates) {
+    const conv = this.getMap().get(conversationId);
+    if (!conv)
+      return null;
+    const updated = {
+      ...conv,
+      ...updates,
+      updatedAt: new Date
+    };
+    this.getMap().set(conversationId, updated);
+    this.persist();
+    return updated;
+  }
+  async appendMessage(conversationId, message) {
+    const conv = this.getMap().get(conversationId);
+    if (!conv)
+      throw new Error(`Conversation ${conversationId} not found`);
+    const now = new Date;
+    const fullMessage = {
+      ...message,
+      id: generateId2("msg"),
+      conversationId,
+      createdAt: now,
+      updatedAt: now
+    };
+    conv.messages.push(fullMessage);
+    conv.updatedAt = now;
+    this.persist();
+    return fullMessage;
+  }
+  async updateMessage(conversationId, messageId, updates) {
+    const conv = this.getMap().get(conversationId);
+    if (!conv)
+      return null;
+    const idx = conv.messages.findIndex((m) => m.id === messageId);
+    if (idx === -1)
+      return null;
+    const msg = conv.messages[idx];
+    if (!msg)
+      return null;
+    const updated = {
+      ...msg,
+      ...updates,
+      updatedAt: new Date
+    };
+    conv.messages[idx] = updated;
+    conv.updatedAt = new Date;
+    this.persist();
+    return updated;
+  }
+  async delete(conversationId) {
+    const deleted = this.getMap().delete(conversationId);
+    if (deleted)
+      this.persist();
+    return deleted;
+  }
+  async list(options) {
+    let results = Array.from(this.getMap().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.getMap().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: generateId2("msg"),
+      conversationId: "",
+      createdAt: new Date(m.createdAt),
+      updatedAt: new Date(m.updatedAt)
+    }));
+    const forked = {
+      ...source,
+      id: generateId2("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.getMap().set(forked.id, forked);
+    this.persist();
+    return forked;
+  }
+  async truncateAfter(conversationId, messageId) {
+    const conv = this.getMap().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;
+    this.persist();
+    return conv;
+  }
+  async search(query, limit = 20) {
+    const lowerQuery = query.toLowerCase();
+    const results = [];
+    for (const conv of this.getMap().values()) {
+      if (conv.title?.toLowerCase().includes(lowerQuery)) {
+        results.push(conv);
+        continue;
+      }
+      if (conv.messages.some((m) => m.content.toLowerCase().includes(lowerQuery))) {
+        results.push(conv);
+      }
+      if (results.length >= limit)
+        break;
+    }
+    return results;
+  }
+}
+function createLocalStorageConversationStore(storageKey) {
+  return new LocalStorageConversationStore(storageKey);
+}
+// src/core/agent-adapter.ts
+function createChatAgentAdapter(agent) {
+  return {
+    async generate({ prompt, signal }) {
+      const result = await agent.generate({ prompt, signal });
+      return {
+        text: result.text,
+        toolCalls: result.toolCalls,
+        toolResults: result.toolResults,
+        usage: result.usage
+      };
+    }
+  };
+}
 export {
+  getProviderOptions,
+  getExportFilename,
+  formatMessagesAsTxt,
+  formatMessagesAsMarkdown,
+  formatMessagesAsJson,
+  exportToFile,
+  downloadAsFile,
+  createWorkflowTools,
+  createSurfacePlannerTools,
+  createLocalStorageConversationStore,
   createInMemoryConversationStore,
   createCompletionRoute,
   createChatService,
   createChatRoute,
+  createChatAgentAdapter,
+  buildPlannerPromptInput,
+  buildContractsContextPrompt,
+  agentToolConfigsToToolSet,
+  THINKING_LEVEL_LABELS,
+  THINKING_LEVEL_DESCRIPTIONS,
+  LocalStorageConversationStore,
   InMemoryConversationStore,
   ChatService
 };