@contractspec/module.ai-chat 4.3.6 → 4.3.10

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

@@ -6,13 +6,109 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// src/presentation/hooks/index.ts
+import { useCompletion } from "@ai-sdk/react";
+
 // src/presentation/hooks/useChat.tsx
-import * as React from "react";
+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) {
@@ -175,6 +271,163 @@ 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",
@@ -227,457 +480,210 @@ function getProviderOptions(level, providerName) {
 }
 
 // src/core/workflow-tools.ts
-import { tool } from "ai";
-import { z } from "zod";
 import {
-  WorkflowComposer,
-  validateExtension
+  validateExtension,
+  WorkflowComposer
 } 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()
+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: z.object({
-    key: z.string(),
-    version: z.number()
+  form: z3.object({
+    key: z3.string(),
+    version: z3.number()
   }).optional()
 }).optional();
-var StepSchema = z.object({
-  id: z.string(),
+var StepSchema = z3.object({
+  id: z3.string(),
   type: StepTypeSchema,
-  label: z.string(),
-  description: z.string().optional(),
+  label: z3.string(),
+  description: z3.string().optional(),
   action: StepActionSchema
 });
-var StepInjectionSchema = z.object({
-  after: z.string().optional(),
-  before: z.string().optional(),
+var StepInjectionSchema = z3.object({
+  after: z3.string().optional(),
+  before: z3.string().optional(),
   inject: StepSchema,
-  transitionTo: z.string().optional(),
-  transitionFrom: z.string().optional(),
-  when: z.string().optional()
+  transitionTo: z3.string().optional(),
+  transitionFrom: z3.string().optional(),
+  when: z3.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()
+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 = tool({
+  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 = 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,
+    inputSchema: WorkflowExtensionInputSchema,
     execute: async (input) => {
-      const ops = input.ops;
+      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 {
-        validatePatchProposal(ops, resolvedConstraints);
-        const proposal = buildSurfacePatchProposal(input.proposalId, ops);
-        onPatchProposal?.(proposal);
+        validateExtension(extension, base);
         return {
           success: true,
-          proposalId: proposal.proposalId,
-          opsCount: proposal.ops.length,
-          message: "Patch proposal validated; awaiting user approval"
+          message: "Extension validated successfully",
+          extension
         };
       } catch (err) {
         return {
           success: false,
           error: err instanceof Error ? err.message : String(err),
-          proposalId: input.proposalId
+          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)}',` : ""}
+    }`).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 {
-    "propose-patch": proposePatchTool
+    create_workflow_extension: createWorkflowExtensionTool,
+    compose_workflow: composeWorkflowTool,
+    generate_workflow_spec_code: generateWorkflowSpecCodeTool
   };
 }
-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"
-    }
-  };
+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
-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:
@@ -1093,9 +1099,6 @@ function createChatService(config) {
 }
 
 // src/presentation/hooks/useChat.tsx
-import {
-  createProvider
-} from "@contractspec/lib.ai-providers";
 "use client";
 function toolsToToolSet(defs) {
   const result = {};
@@ -1534,44 +1537,42 @@ function useChat(options = {}) {
     ...hasApprovalTools && { addToolApprovalResponse }
   };
 }
-// src/presentation/hooks/useProviders.tsx
+// src/presentation/hooks/useConversations.ts
 import * as React2 from "react";
-import {
-  getAvailableProviders,
-  getModelsForProvider
-} from "@contractspec/lib.ai-providers";
 "use client";
-function useProviders() {
-  const [providers, setProviders] = React2.useState([]);
+function useConversations(options) {
+  const { store, projectId, tags, limit = 50 } = options;
+  const [conversations, setConversations] = React2.useState([]);
   const [isLoading, setIsLoading] = React2.useState(true);
-  const loadProviders = React2.useCallback(async () => {
+  const refresh = React2.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);
+      const list = await store.list({
+        status: "active",
+        projectId,
+        tags,
+        limit
+      });
+      setConversations(list);
     } finally {
       setIsLoading(false);
     }
-  }, []);
+  }, [store, projectId, tags, limit]);
   React2.useEffect(() => {
-    loadProviders();
-  }, [loadProviders]);
-  const availableProviders = React2.useMemo(() => providers.filter((p) => p.available), [providers]);
-  const isAvailable = React2.useCallback((provider) => providers.some((p) => p.provider === provider && p.available), [providers]);
-  const getModelsCallback = React2.useCallback((provider) => providers.find((p) => p.provider === provider)?.models ?? [], [providers]);
+    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 {
-    providers,
-    availableProviders,
-    isAvailable,
-    getModels: getModelsCallback,
+    conversations,
     isLoading,
-    refresh: loadProviders
+    refresh,
+    deleteConversation
   };
 }
 // src/presentation/hooks/useMessageSelection.ts
@@ -1617,47 +1618,46 @@ function useMessageSelection(messageIds) {
     selectedCount
   };
 }
-// src/presentation/hooks/useConversations.ts
+// src/presentation/hooks/useProviders.tsx
+import {
+  getAvailableProviders,
+  getModelsForProvider
+} from "@contractspec/lib.ai-providers";
 import * as React4 from "react";
 "use client";
-function useConversations(options) {
-  const { store, projectId, tags, limit = 50 } = options;
-  const [conversations, setConversations] = React4.useState([]);
+function useProviders() {
+  const [providers, setProviders] = React4.useState([]);
   const [isLoading, setIsLoading] = React4.useState(true);
-  const refresh = React4.useCallback(async () => {
+  const loadProviders = React4.useCallback(async () => {
     setIsLoading(true);
     try {
-      const list = await store.list({
-        status: "active",
-        projectId,
-        tags,
-        limit
-      });
-      setConversations(list);
+      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);
     }
-  }, [store, projectId, tags, limit]);
+  }, []);
   React4.useEffect(() => {
-    refresh();
-  }, [refresh]);
-  const deleteConversation = React4.useCallback(async (id) => {
-    const ok = await store.delete(id);
-    if (ok) {
-      setConversations((prev) => prev.filter((c) => c.id !== id));
-    }
-    return ok;
-  }, [store]);
+    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 {
-    conversations,
+    providers,
+    availableProviders,
+    isAvailable,
+    getModels: getModelsCallback,
     isLoading,
-    refresh,
-    deleteConversation
+    refresh: loadProviders
   };
 }
-
-// src/presentation/hooks/index.ts
-import { useCompletion } from "@ai-sdk/react";
 export {
   useProviders,
   useMessageSelection,