@kraken-ai/platform 0.0.1 → 0.0.2

package/dist/server.cjs

@@ -30,6 +30,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/server.ts
 var server_exports = {};
 __export(server_exports, {
+  MockToolSet: () => MockToolSet,
+  runDev: () => runDev,
   startConnectorServer: () => startConnectorServer
 });
 module.exports = __toCommonJS(server_exports);
@@ -104,7 +106,7 @@ var withTimeout = (promise, ms) => Promise.race([
     (_, reject) => setTimeout(() => reject(new Error(`Handler timed out after ${ms}ms`)), ms)
   )
 ]);
-var readBody = (req, maxSize) => new Promise((resolve, reject) => {
+var readBody = (req, maxSize) => new Promise((resolve2, reject) => {
   const chunks = [];
   let size = 0;
   req.on("data", (chunk) => {
@@ -116,7 +118,7 @@ var readBody = (req, maxSize) => new Promise((resolve, reject) => {
     }
     chunks.push(chunk);
   });
-  req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+  req.on("end", () => resolve2(Buffer.concat(chunks).toString()));
   req.on("error", reject);
 });
 var buildPromptArgsSchema = (def) => {
@@ -291,8 +293,8 @@ var startConnectorServer = async (connector, options) => {
     res.end("Not found");
   });
   await mcpServer.connect(transport);
-  await new Promise((resolve) => {
-    httpServer.listen(port, host, () => resolve());
+  await new Promise((resolve2) => {
+    httpServer.listen(port, host, () => resolve2());
   });
   const addr = httpServer.address();
   if (!addr || typeof addr === "string") {
@@ -302,14 +304,504 @@ var startConnectorServer = async (connector, options) => {
     port: addr.port,
     close: async () => {
       await mcpServer.close();
-      await new Promise((resolve, reject) => {
-        httpServer.close((err) => err ? reject(err) : resolve());
+      await new Promise((resolve2, reject) => {
+        httpServer.close((err) => err ? reject(err) : resolve2());
       });
     }
   };
 };
+
+// src/dev.ts
+var import_node_fs = require("fs");
+var import_node_readline = require("readline");
+var import_kraken_ai2 = require("kraken-ai");
+
+// src/agents/define-actions.ts
+var z3 = __toESM(require("zod"), 1);
+
+// src/agents/types/action.ts
+var z2 = __toESM(require("zod"), 1);
+var actionVariantConfigSchema = z2.object({
+  schema: z2.record(z2.string(), z2.unknown()),
+  webhook: z2.string().url().optional(),
+  hasHandler: z2.boolean()
+});
+var actionsConfigSchema = z2.object({
+  variants: z2.record(z2.string(), actionVariantConfigSchema)
+}).strict();
+
+// src/agents/define-actions.ts
+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]) => z3.object({ action: z3.literal(name) }).extend(schema.shape)
+  );
+  const [first, ...rest] = variants;
+  if (!first) {
+    throw new Error("Cannot build output schema from empty action definitions");
+  }
+  return z3.discriminatedUnion("action", [first, ...rest]);
+};
+
+// 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/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
+var import_node_path = require("path");
+var import_kraken_ai = require("kraken-ai");
+
+// 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/dev-connectors.ts
+var isPlatformConnector = (v) => v != null && typeof v === "object" && v.__type === "PlatformConnector";
+var importConnector = async (name, projectRoot) => {
+  const basePath = (0, import_node_path.resolve)(projectRoot, "connectors", name, "index");
+  for (const ext of [".ts", ".js"]) {
+    try {
+      const mod = await import(`${basePath}${ext}`);
+      const connector = mod.default;
+      if (!isPlatformConnector(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]) => (0, import_kraken_ai.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 = (0, import_node_fs.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 (0, import_node_fs.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 import_kraken_ai2.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 = (0, import_node_readline.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 {};
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  MockToolSet,
+  runDev,
   startConnectorServer
 });
 //# sourceMappingURL=server.cjs.map