@contractspec/module.ai-chat 4.3.6 → 4.3.7

package/dist/browser/core/index.js

@@ -5,6 +5,113 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+
+// 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
+      };
+    }
+  };
+}
+// 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/chat-service.ts
+import { generateText, streamText } from "ai";
+import { compilePlannerPrompt } from "@contractspec/lib.surface-runtime/runtime/planner-prompt";
+
+// 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)}`;
@@ -165,8 +272,163 @@ class InMemoryConversationStore {
 function createInMemoryConversationStore() {
   return new InMemoryConversationStore;
 }
-// src/core/chat-service.ts
-import { generateText, streamText } from "ai";
+
+// 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 = {
@@ -220,50 +482,50 @@ 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) => {
@@ -299,13 +561,13 @@ function createWorkflowTools(config) {
       }
     }
   });
-  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 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 = tool({
+  const composeWorkflowTool = tool3({
     description: "Compose a workflow by applying registered extensions to a base workflow. Returns the composed WorkflowSpec.",
     inputSchema: composeWorkflowInputSchema,
     execute: async (input) => {
@@ -349,16 +611,16 @@ function createWorkflowTools(config) {
       }
     }
   });
-  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()
+  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 = tool({
+  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) => {
@@ -423,254 +685,7 @@ 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:
@@ -1612,20 +1627,6 @@ class LocalStorageConversationStore {
 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,