@kraken-ai/platform 0.0.1 → 0.0.3

package/dist/index.js

@@ -1,94 +1,88 @@
 import {
+  ACTION_NAME_REGEX,
   ConnectorError,
   SecurityError,
+  actionVariantConfigSchema,
+  actionsConfigSchema,
+  buildActionOutputSchema,
+  defineAction,
+  defineActions,
+  isValidActionName,
   mcpResult,
   wrapToolError,
   wrapToolResult
-} from "./chunk-HGJSK6MW.js";
-
-// src/agents/types/action.ts
-import * as z from "zod";
-var ACTION_NAME_REGEX = /^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]$/;
-var isValidActionName = (name) => name.length === 1 ? /^[a-z0-9]$/.test(name) : ACTION_NAME_REGEX.test(name);
-var actionVariantConfigSchema = z.object({
-  schema: z.record(z.string(), z.unknown()),
-  webhook: z.string().url().optional(),
-  hasHandler: z.boolean()
-});
-var actionsConfigSchema = z.object({
-  variants: z.record(z.string(), actionVariantConfigSchema)
-}).strict();
+} from "./chunk-PPT6GGYL.js";
 
 // src/agents/types/environment.ts
-import * as z2 from "zod";
-var environmentSchema = z2.enum(["dev", "staging", "prod"]);
+import * as z from "zod";
+var environmentSchema = z.enum(["dev", "staging", "prod"]);
 
 // src/agents/types/identity.ts
-import * as z3 from "zod";
-var jitPolicySchema = z3.enum(["auto-approve", "policy-based", "require-approval"]);
-var identityConfigSchema = z3.object({
-  basePermissions: z3.array(z3.string()),
-  requestablePermissions: z3.array(z3.string()).optional(),
+import * as z2 from "zod";
+var jitPolicySchema = z2.enum(["auto-approve", "policy-based", "require-approval"]);
+var identityConfigSchema = z2.object({
+  basePermissions: z2.array(z2.string()),
+  requestablePermissions: z2.array(z2.string()).optional(),
   jitPolicy: jitPolicySchema.optional(),
-  maxJitDurationMinutes: z3.number().int().positive().optional()
+  maxJitDurationMinutes: z2.number().int().positive().optional()
 });
 
 // src/agents/types/notifications.ts
-import * as z4 from "zod";
-var notificationConfigSchema = z4.object({
-  slack: z4.string().optional(),
-  onSuccess: z4.boolean().optional(),
-  onFailure: z4.boolean().optional(),
-  onTimeout: z4.boolean().optional()
+import * as z3 from "zod";
+var notificationConfigSchema = z3.object({
+  slack: z3.string().optional(),
+  onSuccess: z3.boolean().optional(),
+  onFailure: z3.boolean().optional(),
+  onTimeout: z3.boolean().optional()
 });
 
 // src/agents/types/platform-agent.ts
-import * as z8 from "zod";
+import * as z7 from "zod";
 
 // src/agents/types/resources.ts
-import * as z5 from "zod";
-var resourceLimitsSchema = z5.object({
-  maxTokens: z5.number().int().positive().optional(),
-  maxCostUsd: z5.number().positive().optional(),
-  timeoutSeconds: z5.number().int().positive().optional()
+import * as z4 from "zod";
+var resourceLimitsSchema = z4.object({
+  maxTokens: z4.number().int().positive().optional(),
+  maxCostUsd: z4.number().positive().optional(),
+  timeoutSeconds: z4.number().int().positive().optional()
 });
-var retryPolicySchema = z5.object({
-  maxAttempts: z5.number().int().min(1).optional(),
-  backoffSeconds: z5.number().positive().optional()
+var retryPolicySchema = z4.object({
+  maxAttempts: z4.number().int().min(1).optional(),
+  backoffSeconds: z4.number().positive().optional()
 });
-var concurrencyPolicySchema = z5.object({
-  maxParallelRuns: z5.number().int().min(1).optional()
+var concurrencyPolicySchema = z4.object({
+  maxParallelRuns: z4.number().int().min(1).optional()
 });
 
 // src/agents/types/team.ts
-import * as z6 from "zod";
-var teamConfigSchema = z6.object({
-  members: z6.array(z6.string()).min(1),
-  maxConcurrentWorkers: z6.number().int().min(1).optional(),
-  maxTokenBudgetPerWorker: z6.number().int().positive().optional(),
-  maxDurationPerWorker: z6.number().positive().optional()
+import * as z5 from "zod";
+var teamConfigSchema = z5.object({
+  members: z5.array(z5.string()).min(1),
+  maxConcurrentWorkers: z5.number().int().min(1).optional(),
+  maxTokenBudgetPerWorker: z5.number().int().positive().optional(),
+  maxDurationPerWorker: z5.number().positive().optional()
 });
 
 // src/agents/types/trigger.ts
-import * as z7 from "zod";
-var cronTriggerSchema = z7.object({
-  type: z7.literal("cron"),
-  expression: z7.string(),
-  timezone: z7.string().optional()
+import * as z6 from "zod";
+var cronTriggerSchema = z6.object({
+  type: z6.literal("cron"),
+  expression: z6.string(),
+  timezone: z6.string().optional()
 });
-var webhookTriggerSchema = z7.object({
-  type: z7.literal("webhook"),
-  path: z7.string().startsWith("/"),
-  method: z7.enum(["POST", "GET"]).optional()
+var webhookTriggerSchema = z6.object({
+  type: z6.literal("webhook"),
+  path: z6.string().startsWith("/"),
+  method: z6.enum(["POST", "GET"]).optional()
 });
-var eventTriggerSchema = z7.object({
-  type: z7.literal("event"),
-  source: z7.string(),
-  event: z7.string()
+var eventTriggerSchema = z6.object({
+  type: z6.literal("event"),
+  source: z6.string(),
+  event: z6.string()
 });
-var apiTriggerSchema = z7.object({ type: z7.literal("api") });
-var manualTriggerSchema = z7.object({ type: z7.literal("manual") });
-var triggerConfigSchema = z7.discriminatedUnion("type", [
+var apiTriggerSchema = z6.object({ type: z6.literal("api") });
+var manualTriggerSchema = z6.object({ type: z6.literal("manual") });
+var triggerConfigSchema = z6.discriminatedUnion("type", [
   cronTriggerSchema,
   webhookTriggerSchema,
   eventTriggerSchema,
@@ -97,23 +91,23 @@ var triggerConfigSchema = z7.discriminatedUnion("type", [
 ]);
 
 // src/agents/types/platform-agent.ts
-var thinkingLevelSchema = z8.enum(["low", "medium", "high"]);
-var logLevelSchema = z8.enum(["silent", "debug", "info", "warn", "error"]);
-var agentDefinitionSchema = z8.object({
-  name: z8.string().min(1),
-  model: z8.string().min(1),
-  instructions: z8.string().min(1),
-  description: z8.string().optional(),
-  skills: z8.array(z8.string()).optional(),
-  temperature: z8.number().min(0).max(2).optional(),
-  allowTemperatureOverride: z8.boolean().optional(),
-  maxOutputTokens: z8.number().int().positive().optional(),
+var thinkingLevelSchema = z7.enum(["low", "medium", "high"]);
+var logLevelSchema = z7.enum(["silent", "debug", "info", "warn", "error"]);
+var agentDefinitionSchema = z7.object({
+  name: z7.string().min(1),
+  model: z7.string().min(1),
+  instructions: z7.string().min(1),
+  description: z7.string().optional(),
+  skills: z7.array(z7.string()).optional(),
+  temperature: z7.number().min(0).max(2).optional(),
+  allowTemperatureOverride: z7.boolean().optional(),
+  maxOutputTokens: z7.number().int().positive().optional(),
   thinkingLevel: thinkingLevelSchema.optional(),
   logLevel: logLevelSchema.optional()
 }).strict();
-var platformAgentConfigSchema = z8.object({
+var platformAgentConfigSchema = z7.object({
   agent: agentDefinitionSchema,
-  connectors: z8.array(z8.string()).optional(),
+  connectors: z7.array(z7.string()).optional(),
   trigger: triggerConfigSchema,
   identity: identityConfigSchema.optional(),
   resources: resourceLimitsSchema.optional(),
@@ -126,10 +120,10 @@ var platformAgentConfigSchema = z8.object({
 }).strict();
 
 // src/agents/types/skill.ts
-import * as z9 from "zod";
-var platformSkillInputSchema = z9.object({
-  name: z9.string().min(1),
-  description: z9.string().optional()
+import * as z8 from "zod";
+var platformSkillInputSchema = z8.object({
+  name: z8.string().min(1),
+  description: z8.string().optional()
 }).strict();
 
 // src/agents/define.ts
@@ -203,59 +197,6 @@ var definePlatformAgent = (config) => {
   };
 };
 
-// src/agents/define-actions.ts
-import * as z10 from "zod";
-var defineAction = (input) => input;
-var defineActions = (variants) => {
-  const entries = Object.entries(variants);
-  if (entries.length === 0) {
-    throw new Error("defineActions() requires at least one action variant");
-  }
-  if (entries.length > 20) {
-    throw new Error("defineActions() supports a maximum of 20 action variants");
-  }
-  const serialized = {};
-  const zodSchemas = {};
-  const handlers = {};
-  for (const [name, variant] of entries) {
-    if (!isValidActionName(name)) {
-      throw new Error(
-        `Invalid action name "${name}": must be lowercase alphanumeric with hyphens, 1-64 chars`
-      );
-    }
-    const v = variant;
-    serialized[name] = {
-      schema: z10.toJSONSchema(v.schema, { target: "draft-2020-12" }),
-      webhook: v.webhook,
-      hasHandler: !!v.handler
-    };
-    zodSchemas[name] = v.schema;
-    if (v.handler) {
-      handlers[name] = v.handler;
-    }
-  }
-  return Object.freeze({
-    __type: "PlatformActions",
-    config: Object.freeze({ variants: Object.freeze(serialized) }),
-    zodSchemas: Object.freeze(zodSchemas),
-    handlers: Object.freeze(handlers)
-  });
-};
-var buildActionOutputSchema = (actions) => {
-  const entries = Object.entries(actions.zodSchemas);
-  if (entries.length === 0) {
-    throw new Error("Cannot build output schema from empty action definitions");
-  }
-  const variants = entries.map(
-    ([name, schema]) => z10.object({ action: z10.literal(name) }).extend(schema.shape)
-  );
-  const [first, ...rest] = variants;
-  if (!first) {
-    throw new Error("Cannot build output schema from empty action definitions");
-  }
-  return z10.discriminatedUnion("action", [first, ...rest]);
-};
-
 // src/agents/define-connector.ts
 var defineTool = (def) => def;
 var defineConnector = (input) => {
@@ -290,47 +231,27 @@ var defineSkill = (input) => {
 import fs from "fs";
 import path from "path";
 import { pathToFileURL } from "url";
-import * as z11 from "zod";
-
-// src/cli/log.ts
-var supportsColor = !("NO_COLOR" in process.env) && process.env.FORCE_COLOR !== "0" && (process.stderr.isTTY ?? false);
-var code = (open, close) => {
-  const openStr = `\x1B[${open}m`;
-  const closeStr = `\x1B[${close}m`;
-  return (s) => supportsColor ? `${openStr}${s}${closeStr}` : s;
-};
-var bold = code(1, 22);
-var dim = code(2, 22);
-var red = code(31, 39);
-var yellow = code(33, 39);
-var green = code(32, 39);
-var cyan = code(36, 39);
-
-// src/cli/validate.ts
-var ENTITY_NAME_REGEX = /^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]$/;
-var isValidEntityName = (name) => name.length === 1 ? /^[a-z0-9]$/.test(name) : ENTITY_NAME_REGEX.test(name);
-
-// src/cli/discover.ts
+import * as z9 from "zod";
 var MANIFEST_START = "---KRAKEN-MANIFEST-START---";
 var MANIFEST_END = "---KRAKEN-MANIFEST-END---";
-var skillEntrySchema = z11.object({
-  name: z11.string().min(1),
-  path: z11.string().min(1),
-  content: z11.string()
+var skillEntrySchema = z9.object({
+  name: z9.string().min(1),
+  path: z9.string().min(1),
+  content: z9.string()
 });
-var connectorEntrySchema = z11.object({
-  name: z11.string().min(1),
-  path: z11.string().min(1)
+var connectorEntrySchema = z9.object({
+  name: z9.string().min(1),
+  path: z9.string().min(1)
 });
-var agentEntrySchema = z11.object({
-  name: z11.string().min(1),
-  entryPoint: z11.string().min(1),
+var agentEntrySchema = z9.object({
+  name: z9.string().min(1),
+  entryPoint: z9.string().min(1),
   config: platformAgentConfigSchema
 });
-var projectManifestSchema = z11.object({
-  agents: z11.array(agentEntrySchema),
-  skills: z11.array(skillEntrySchema),
-  connectors: z11.array(connectorEntrySchema)
+var projectManifestSchema = z9.object({
+  agents: z9.array(agentEntrySchema),
+  skills: z9.array(skillEntrySchema),
+  connectors: z9.array(connectorEntrySchema)
 });
 var MAX_SKILL_SIZE = 100 * 1024;
 var parseManifestFromOutput = (stdout) => {
@@ -353,444 +274,6 @@ var parseManifestFromOutput = (stdout) => {
   return result.data;
 };
 
-// src/dev.ts
-import { readFileSync } from "fs";
-import { createInterface } from "readline";
-import { Agent } from "kraken-ai";
-
-// src/dev-actions.ts
-var buildActionInstructions = (zodSchemas) => {
-  const entries = Object.entries(zodSchemas);
-  if (entries.length === 0) return "";
-  const variants = entries.map(([name, schema]) => {
-    const fields = Object.keys(schema.shape).join(", ");
-    return `  - "${name}": { ${fields} }`;
-  });
-  return [
-    'You MUST respond with a JSON object containing an "action" field set to one of the following action names, plus the fields for that action:',
-    "",
-    ...variants,
-    "",
-    'Example: { "action": "<name>", ...fields }'
-  ].join("\n");
-};
-var dispatchDevAction = async (output, zodSchemas, handlers, webhooks) => {
-  if (output == null || typeof output !== "object" || !("action" in output)) {
-    throw new Error('Action output must contain an "action" field');
-  }
-  const { action: actionName, ...rest } = output;
-  if (typeof actionName !== "string") {
-    throw new Error('Action output "action" field must be a string');
-  }
-  const schema = zodSchemas[actionName];
-  if (!schema) {
-    throw new Error(
-      `Unknown action "${actionName}". Expected one of: ${Object.keys(zodSchemas).join(", ")}`
-    );
-  }
-  const parsed = schema.parse(rest);
-  const payload = parsed;
-  let handlerCalled = false;
-  const handler = handlers?.[actionName];
-  if (handler) {
-    await handler(payload);
-    handlerCalled = true;
-  }
-  return {
-    actionName,
-    payload,
-    handlerCalled,
-    webhookUrl: webhooks[actionName]
-  };
-};
-
-// src/dev-connectors.ts
-import { resolve } from "path";
-import { tool } from "kraken-ai";
-var isPlatformConnector2 = (v) => v != null && typeof v === "object" && v.__type === "PlatformConnector";
-var importConnector = async (name, projectRoot) => {
-  const basePath = resolve(projectRoot, "connectors", name, "index");
-  for (const ext of [".ts", ".js"]) {
-    try {
-      const mod = await import(`${basePath}${ext}`);
-      const connector = mod.default;
-      if (!isPlatformConnector2(connector)) {
-        console.warn(`[connector:${name}] Default export is not a PlatformConnector \u2014 skipping`);
-        return null;
-      }
-      return connector;
-    } catch (err) {
-      if (ext === ".ts") continue;
-      const message = err instanceof Error ? err.message : String(err);
-      console.warn(`[connector:${name}] Failed to import \u2014 skipping. Error: ${message}`);
-      return null;
-    }
-  }
-  return null;
-};
-var createToolsFromConnector = (connector) => {
-  const tools = connector.tools ?? {};
-  return Object.entries(tools).map(
-    ([name, def]) => tool({
-      name,
-      description: def.description,
-      parameters: def.input,
-      execute: async (args) => {
-        try {
-          const result = await Promise.resolve(def.handler(args));
-          return wrapToolResult(result);
-        } catch (error) {
-          return wrapToolError(error);
-        }
-      }
-    })
-  );
-};
-var buildConnectorTools = (connectors) => {
-  const toolOwners = /* @__PURE__ */ new Map();
-  for (const { name, connector } of connectors) {
-    for (const toolName of Object.keys(connector.tools ?? {})) {
-      const existing = toolOwners.get(toolName);
-      if (existing) {
-        throw new Error(
-          `Tool name collision: "${toolName}" is defined by both connectors "${existing}" and "${name}". Rename one of the tools or use a unique prefix.`
-        );
-      }
-      toolOwners.set(toolName, name);
-    }
-  }
-  const resourceOwners = /* @__PURE__ */ new Map();
-  for (const { name, connector } of connectors) {
-    for (const resourceName of Object.keys(connector.resources ?? {})) {
-      const existing = resourceOwners.get(resourceName);
-      if (existing) {
-        throw new Error(
-          `Resource name collision: "${resourceName}" is defined by both connectors "${existing}" and "${name}". Rename one of the resources or use a unique prefix.`
-        );
-      }
-      resourceOwners.set(resourceName, name);
-    }
-  }
-  const promptOwners = /* @__PURE__ */ new Map();
-  for (const { name, connector } of connectors) {
-    for (const promptName of Object.keys(connector.prompts ?? {})) {
-      const existing = promptOwners.get(promptName);
-      if (existing) {
-        throw new Error(
-          `Prompt name collision: "${promptName}" is defined by both connectors "${existing}" and "${name}". Rename one of the prompts or use a unique prefix.`
-        );
-      }
-      promptOwners.set(promptName, name);
-    }
-  }
-  const allTools = [];
-  const allResources = [];
-  const allPrompts = [];
-  const allInstructions = [];
-  for (const { name, connector } of connectors) {
-    const tools = createToolsFromConnector(connector);
-    allTools.push(...tools);
-    for (const [resName, resDef] of Object.entries(connector.resources ?? {})) {
-      allResources.push({
-        name: resName,
-        uri: resDef.uri,
-        description: resDef.description,
-        mimeType: resDef.mimeType,
-        read: (ctx) => resDef.read(ctx)
-      });
-    }
-    for (const [promptName, promptDef] of Object.entries(connector.prompts ?? {})) {
-      allPrompts.push({
-        name: promptName,
-        description: promptDef.description,
-        arguments: promptDef.arguments,
-        get: (args, ctx) => promptDef.get(args, ctx)
-      });
-    }
-    const toolCount = Object.keys(connector.tools ?? {}).length;
-    const resourceCount = Object.keys(connector.resources ?? {}).length;
-    const promptCount = Object.keys(connector.prompts ?? {}).length;
-    const parts = [
-      `${toolCount} tool${toolCount !== 1 ? "s" : ""}`,
-      `${resourceCount} resource${resourceCount !== 1 ? "s" : ""}`,
-      `${promptCount} prompt${promptCount !== 1 ? "s" : ""}`
-    ];
-    console.log(`  Connector: ${name} (${parts.join(", ")})`);
-    if (connector.instructions) {
-      allInstructions.push(connector.instructions);
-    }
-  }
-  return {
-    tools: allTools,
-    resources: allResources,
-    prompts: allPrompts,
-    instructions: allInstructions
-  };
-};
-var loadConnectorTools = async (connectorNames, projectRoot) => {
-  if (connectorNames.length === 0) {
-    return { tools: [], resources: [], prompts: [], instructions: [] };
-  }
-  const root = projectRoot ?? process.cwd();
-  const connectors = [];
-  for (const name of connectorNames) {
-    if (!isValidEntityName(name)) {
-      console.warn(
-        `[connector] Invalid connector name "${name}" \u2014 must match ${ENTITY_NAME_REGEX}. Skipping.`
-      );
-      continue;
-    }
-    const connector = await importConnector(name, root);
-    if (connector) {
-      connectors.push({ name, connector });
-    }
-  }
-  return buildConnectorTools(connectors);
-};
-
-// src/dev.ts
-var loadDotenv = () => {
-  try {
-    const content = readFileSync(".env", "utf-8");
-    for (const line of content.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-      const eqIdx = trimmed.indexOf("=");
-      if (eqIdx === -1) continue;
-      const key = trimmed.slice(0, eqIdx).trim();
-      const value = trimmed.slice(eqIdx + 1).trim();
-      if (!process.env[key]) {
-        process.env[key] = value;
-      }
-    }
-  } catch {
-  }
-};
-var FRONTMATTER_RE = /^---\n[\s\S]*?\n---\n([\s\S]*)$/;
-var resolveSkillContent = (refs) => refs.map((ref) => {
-  try {
-    return readFileSync(`skills/${ref}`, "utf-8");
-  } catch {
-    return ref;
-  }
-});
-var buildInstructions = (base, skillContent) => {
-  if (skillContent.length === 0) return base;
-  const bodies = skillContent.map((s) => {
-    const m = FRONTMATTER_RE.exec(s);
-    return m?.[1]?.trim() ?? s;
-  });
-  return `${base}
-
-${bodies.join("\n\n")}`;
-};
-var buildDevAgent = async (pa) => {
-  const {
-    name,
-    model,
-    instructions,
-    skills,
-    temperature,
-    thinkingLevel,
-    maxOutputTokens,
-    logLevel
-  } = pa.config.agent;
-  const connectorNames = pa.config.connectors ?? [];
-  const { tools: connectorTools, instructions: connectorInstructions } = await loadConnectorTools(connectorNames);
-  const skillContent = resolveSkillContent(skills ?? []);
-  let fullInstructions = buildInstructions(instructions, skillContent);
-  if (connectorInstructions.length > 0) {
-    fullInstructions = `${fullInstructions}
-
-${connectorInstructions.join("\n\n")}`;
-  }
-  let outputSchema;
-  if (pa.actionZodSchemas && Object.keys(pa.actionZodSchemas).length > 0) {
-    const actionInstructions = buildActionInstructions(pa.actionZodSchemas);
-    if (actionInstructions) {
-      fullInstructions = `${fullInstructions}
-
-${actionInstructions}`;
-    }
-    outputSchema = buildActionOutputSchema({
-      __type: "PlatformActions",
-      config: pa.config.actions ?? { variants: {} },
-      zodSchemas: pa.actionZodSchemas,
-      handlers: pa.actionHandlers ?? {}
-    });
-  }
-  let team;
-  if (pa.teamAgents && pa.teamAgents.length > 0) {
-    team = await Promise.all(pa.teamAgents.map(buildDevAgent));
-  }
-  return new Agent({
-    name,
-    model,
-    instructions: fullInstructions,
-    tools: connectorTools.length > 0 ? connectorTools : void 0,
-    outputSchema,
-    team,
-    temperature,
-    thinkingLevel,
-    maxOutputTokens,
-    logLevel
-  });
-};
-var runDev = async (agent) => {
-  loadDotenv();
-  const hasActions = agent.actionZodSchemas && Object.keys(agent.actionZodSchemas).length > 0;
-  const sdkAgent = await buildDevAgent(agent);
-  const { name, model } = agent.config.agent;
-  const connectorNames = agent.config.connectors ?? [];
-  try {
-    await sdkAgent.preflight();
-  } catch (err) {
-    console.error(`
-  ${err instanceof Error ? err.message : String(err)}
-`);
-    process.exit(1);
-  }
-  console.log(`
-  Agent: ${name}`);
-  console.log(`  Model: ${model}`);
-  if (connectorNames.length > 0) {
-    console.log(`  Connectors: ${connectorNames.join(", ")}`);
-  }
-  if (agent.teamAgents && agent.teamAgents.length > 0) {
-    console.log(`  Team: ${agent.teamAgents.map((a) => a.config.agent.name).join(", ")}`);
-  }
-  if (hasActions && agent.actionZodSchemas) {
-    console.log(`  Actions: ${Object.keys(agent.actionZodSchemas).join(", ")}`);
-  }
-  console.log(`
-  Type a message to start. Ctrl+C to exit.
-`);
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  const messages = [];
-  const cleanup = () => {
-    rl.close();
-    process.exit(0);
-  };
-  process.on("SIGINT", cleanup);
-  process.on("SIGTERM", cleanup);
-  const ask = () => {
-    rl.question("You: ", (input) => {
-      if (!input.trim()) {
-        ask();
-        return;
-      }
-      messages.push({ role: "user", content: input });
-      void (async () => {
-        try {
-          const result = await sdkAgent.run(messages, {
-            onEvent: (event) => {
-              if (event.type === "thought") {
-                console.log(
-                  `  [thinking] ${event.text.slice(0, 120)}${event.text.length > 120 ? "\u2026" : ""}`
-                );
-              }
-              if (event.type === "tool_call" && event.status === "success") {
-                console.log(`  [tool] ${event.toolName}`);
-              }
-            }
-          });
-          if (result.status === "complete") {
-            const output = typeof result.output === "string" ? result.output : JSON.stringify(result.output, null, 2);
-            if (hasActions && agent.actionZodSchemas && result.output != null && typeof result.output === "object" && "action" in result.output) {
-              const webhooks = {};
-              if (agent.config.actions?.variants) {
-                for (const [k, v] of Object.entries(agent.config.actions.variants)) {
-                  webhooks[k] = v.webhook;
-                }
-              }
-              try {
-                const dispatched = await dispatchDevAction(
-                  result.output,
-                  agent.actionZodSchemas,
-                  agent.actionHandlers,
-                  webhooks
-                );
-                console.log(`
-  ${cyan("Action:")} ${green(dispatched.actionName)}`);
-                console.log(`  ${dim("Payload:")} ${JSON.stringify(dispatched.payload, null, 2)}`);
-                if (dispatched.handlerCalled) {
-                  console.log(`  ${dim("Handler:")} ${green("called")}`);
-                }
-                if (dispatched.webhookUrl) {
-                  console.log(
-                    `  ${dim("Webhook:")} ${yellow(dispatched.webhookUrl)} ${dim("(skipped in dev)")}`
-                  );
-                }
-                console.log();
-              } catch (err) {
-                console.error(
-                  `
-  Action dispatch error: ${err instanceof Error ? err.message : String(err)}
-`
-                );
-              }
-            } else {
-              console.log(`
-Agent: ${output}
-`);
-            }
-            messages.push({ role: "assistant", content: output });
-          } else if (result.status === "interrupted") {
-            console.log(`
-[Interrupted: ${result.interrupt.toolName} requires approval]
-`);
-          }
-        } catch (err) {
-          console.error(`
-Error: ${err instanceof Error ? err.message : String(err)}
-`);
-        }
-        ask();
-      })();
-    });
-  };
-  ask();
-  return new Promise(() => {
-  });
-};
-
-// src/mock-tool-set.ts
-var MockToolSet = class _MockToolSet {
-  defs;
-  overrides;
-  toolNames;
-  constructor(tools, overrides = {}) {
-    this.defs = tools;
-    this.overrides = overrides;
-    this.toolNames = new Set(tools.map((t) => t.name));
-  }
-  static fromConnectors(connectors, opts) {
-    const include = opts?.include;
-    const filtered = include ? connectors.filter((c) => include.includes(c.id)) : connectors;
-    const tools = filtered.flatMap(
-      (c) => c.tools.map((t) => ({
-        name: t.name,
-        description: t.description,
-        parameters: t.parameters
-      }))
-    );
-    return new _MockToolSet(tools, opts?.overrides);
-  }
-  definitions() {
-    return this.defs;
-  }
-  async call(name, params) {
-    if (!this.toolNames.has(name)) {
-      throw new Error(`Unknown tool: ${name}`);
-    }
-    const override = this.overrides[name];
-    if (override) {
-      return override(params);
-    }
-    return {};
-  }
-};
-
 // src/platform/http.ts
 var PlatformError = class extends Error {
   constructor(message, status) {
@@ -921,13 +404,13 @@ var parseBlock = (block) => {
 
 // src/platform/agent-handle.ts
 var deferred = () => {
-  let resolve2;
+  let resolve;
   let reject;
   const promise = new Promise((res, rej) => {
-    resolve2 = res;
+    resolve = res;
     reject = rej;
   });
-  return { promise, resolve: resolve2, reject };
+  return { promise, resolve, reject };
 };
 var AgentHandle = class {
   constructor(http, agentId, opts) {
@@ -1093,7 +576,7 @@ var DataNamespace = class {
 };
 
 // src/platform/pipelines.ts
-import * as z12 from "zod";
+import * as z10 from "zod";
 var PipelinesNamespace = class {
   constructor(http) {
     this.http = http;
@@ -1104,7 +587,7 @@ var PipelinesNamespace = class {
       params
     );
     try {
-      return z12.array(schema.returns).parse(result.rows);
+      return z10.array(schema.returns).parse(result.rows);
     } catch (e) {
       throw new Error(
         `Pipeline schema may have changed \u2014 run 'kraken generate' to update types.
@@ -1205,7 +688,6 @@ export {
   ConnectorError,
   MANIFEST_END,
   MANIFEST_START,
-  MockToolSet,
   PlatformClient,
   PlatformError,
   SecurityError,
@@ -1231,7 +713,6 @@ export {
   projectManifestSchema,
   resourceLimitsSchema,
   retryPolicySchema,
-  runDev,
   teamConfigSchema,
   triggerConfigSchema,
   wrapToolError,