@kraken-ai/platform 0.0.1

package/dist/index.cjs

@@ -0,0 +1,1381 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ACTION_NAME_REGEX: () => ACTION_NAME_REGEX,
+  AgentHandle: () => AgentHandle,
+  AgentThread: () => AgentThread,
+  ConnectorError: () => ConnectorError,
+  MANIFEST_END: () => MANIFEST_END,
+  MANIFEST_START: () => MANIFEST_START,
+  MockToolSet: () => MockToolSet,
+  PlatformClient: () => PlatformClient,
+  PlatformError: () => PlatformError,
+  SecurityError: () => SecurityError,
+  actionVariantConfigSchema: () => actionVariantConfigSchema,
+  actionsConfigSchema: () => actionsConfigSchema,
+  agentDefinitionSchema: () => agentDefinitionSchema,
+  buildActionOutputSchema: () => buildActionOutputSchema,
+  concurrencyPolicySchema: () => concurrencyPolicySchema,
+  defineAction: () => defineAction,
+  defineActions: () => defineActions,
+  defineConnector: () => defineConnector,
+  definePlatformAgent: () => definePlatformAgent,
+  defineSkill: () => defineSkill,
+  defineTool: () => defineTool,
+  environmentSchema: () => environmentSchema,
+  identityConfigSchema: () => identityConfigSchema,
+  isValidActionName: () => isValidActionName,
+  jitPolicySchema: () => jitPolicySchema,
+  mcpResult: () => mcpResult,
+  notificationConfigSchema: () => notificationConfigSchema,
+  parseManifestFromOutput: () => parseManifestFromOutput,
+  platformAgentConfigSchema: () => platformAgentConfigSchema,
+  projectManifestSchema: () => projectManifestSchema,
+  resourceLimitsSchema: () => resourceLimitsSchema,
+  retryPolicySchema: () => retryPolicySchema,
+  runDev: () => runDev,
+  teamConfigSchema: () => teamConfigSchema,
+  triggerConfigSchema: () => triggerConfigSchema,
+  wrapToolError: () => wrapToolError,
+  wrapToolResult: () => wrapToolResult
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/agents/connector-server.ts
+var import_node_crypto = require("crypto");
+var import_node_http = require("http");
+var z = __toESM(require("zod"), 1);
+
+// src/agents/errors.ts
+var SecurityError = class extends Error {
+  code = "SECURITY_VIOLATION";
+  constructor(message) {
+    super(message);
+    this.name = "SecurityError";
+  }
+};
+var ConnectorError = class extends Error {
+  code = "CONNECTOR_ERROR";
+  constructor(message) {
+    super(message);
+    this.name = "ConnectorError";
+  }
+};
+
+// src/agents/connector-wrap.ts
+var MAX_TOOL_RESULT_SIZE = 10 * 1024 * 1024;
+var isMcpContent = (val) => typeof val === "object" && val !== null && "__mcpPassThrough" in val && val.__mcpPassThrough === true;
+var wrapToolResult = (value) => {
+  if (value === null || value === void 0) {
+    return { content: [] };
+  }
+  if (typeof value === "string") {
+    return { content: [{ type: "text", text: value }] };
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return { content: [{ type: "text", text: String(value) }] };
+  }
+  if (isMcpContent(value)) {
+    const result = { content: value.content };
+    if (value.isError) {
+      return { ...result, isError: true };
+    }
+    return result;
+  }
+  const json = JSON.stringify(value, null, 2);
+  if (json.length > MAX_TOOL_RESULT_SIZE) {
+    return {
+      content: [{ type: "text", text: `[Result truncated: ${json.length} bytes]` }],
+      isError: true
+    };
+  }
+  return { content: [{ type: "text", text: json }] };
+};
+var wrapToolError = (error) => {
+  if (error instanceof ConnectorError) {
+    return {
+      content: [{ type: "text", text: error.message }],
+      isError: true
+    };
+  }
+  if (error instanceof Error) {
+    console.error("[connector] Internal handler error:", error.message, error.stack);
+  } else {
+    console.error("[connector] Internal handler error:", String(error));
+  }
+  return {
+    content: [{ type: "text", text: "Internal handler error" }],
+    isError: true
+  };
+};
+var mcpResult = (content, isError) => ({
+  __mcpPassThrough: true,
+  content,
+  isError
+});
+
+// src/agents/connector-server.ts
+var MAX_BODY_SIZE = 10 * 1024 * 1024;
+
+// src/agents/types/action.ts
+var z2 = __toESM(require("zod"), 1);
+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 = 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/types/environment.ts
+var z3 = __toESM(require("zod"), 1);
+var environmentSchema = z3.enum(["dev", "staging", "prod"]);
+
+// src/agents/types/identity.ts
+var z4 = __toESM(require("zod"), 1);
+var jitPolicySchema = z4.enum(["auto-approve", "policy-based", "require-approval"]);
+var identityConfigSchema = z4.object({
+  basePermissions: z4.array(z4.string()),
+  requestablePermissions: z4.array(z4.string()).optional(),
+  jitPolicy: jitPolicySchema.optional(),
+  maxJitDurationMinutes: z4.number().int().positive().optional()
+});
+
+// src/agents/types/notifications.ts
+var z5 = __toESM(require("zod"), 1);
+var notificationConfigSchema = z5.object({
+  slack: z5.string().optional(),
+  onSuccess: z5.boolean().optional(),
+  onFailure: z5.boolean().optional(),
+  onTimeout: z5.boolean().optional()
+});
+
+// src/agents/types/platform-agent.ts
+var z9 = __toESM(require("zod"), 1);
+
+// src/agents/types/resources.ts
+var z6 = __toESM(require("zod"), 1);
+var resourceLimitsSchema = z6.object({
+  maxTokens: z6.number().int().positive().optional(),
+  maxCostUsd: z6.number().positive().optional(),
+  timeoutSeconds: z6.number().int().positive().optional()
+});
+var retryPolicySchema = z6.object({
+  maxAttempts: z6.number().int().min(1).optional(),
+  backoffSeconds: z6.number().positive().optional()
+});
+var concurrencyPolicySchema = z6.object({
+  maxParallelRuns: z6.number().int().min(1).optional()
+});
+
+// src/agents/types/team.ts
+var z7 = __toESM(require("zod"), 1);
+var teamConfigSchema = z7.object({
+  members: z7.array(z7.string()).min(1),
+  maxConcurrentWorkers: z7.number().int().min(1).optional(),
+  maxTokenBudgetPerWorker: z7.number().int().positive().optional(),
+  maxDurationPerWorker: z7.number().positive().optional()
+});
+
+// src/agents/types/trigger.ts
+var z8 = __toESM(require("zod"), 1);
+var cronTriggerSchema = z8.object({
+  type: z8.literal("cron"),
+  expression: z8.string(),
+  timezone: z8.string().optional()
+});
+var webhookTriggerSchema = z8.object({
+  type: z8.literal("webhook"),
+  path: z8.string().startsWith("/"),
+  method: z8.enum(["POST", "GET"]).optional()
+});
+var eventTriggerSchema = z8.object({
+  type: z8.literal("event"),
+  source: z8.string(),
+  event: z8.string()
+});
+var apiTriggerSchema = z8.object({ type: z8.literal("api") });
+var manualTriggerSchema = z8.object({ type: z8.literal("manual") });
+var triggerConfigSchema = z8.discriminatedUnion("type", [
+  cronTriggerSchema,
+  webhookTriggerSchema,
+  eventTriggerSchema,
+  apiTriggerSchema,
+  manualTriggerSchema
+]);
+
+// src/agents/types/platform-agent.ts
+var thinkingLevelSchema = z9.enum(["low", "medium", "high"]);
+var logLevelSchema = z9.enum(["silent", "debug", "info", "warn", "error"]);
+var agentDefinitionSchema = z9.object({
+  name: z9.string().min(1),
+  model: z9.string().min(1),
+  instructions: z9.string().min(1),
+  description: z9.string().optional(),
+  skills: z9.array(z9.string()).optional(),
+  temperature: z9.number().min(0).max(2).optional(),
+  allowTemperatureOverride: z9.boolean().optional(),
+  maxOutputTokens: z9.number().int().positive().optional(),
+  thinkingLevel: thinkingLevelSchema.optional(),
+  logLevel: logLevelSchema.optional()
+}).strict();
+var platformAgentConfigSchema = z9.object({
+  agent: agentDefinitionSchema,
+  connectors: z9.array(z9.string()).optional(),
+  trigger: triggerConfigSchema,
+  identity: identityConfigSchema.optional(),
+  resources: resourceLimitsSchema.optional(),
+  retries: retryPolicySchema.optional(),
+  concurrency: concurrencyPolicySchema.optional(),
+  team: teamConfigSchema.optional(),
+  notifications: notificationConfigSchema.optional(),
+  environment: environmentSchema.optional(),
+  actions: actionsConfigSchema.optional()
+}).strict();
+
+// src/agents/types/skill.ts
+var z10 = __toESM(require("zod"), 1);
+var platformSkillInputSchema = z10.object({
+  name: z10.string().min(1),
+  description: z10.string().optional()
+}).strict();
+
+// src/agents/define.ts
+var FORBIDDEN_AGENT_KEYS = ["tools", "team", "kernel"];
+var isAgentInstance = (value) => value != null && typeof value === "object" && "definition" in value && "name" in value && "run" in value && typeof value.run === "function";
+var assertNoInjection = (agent) => {
+  if (agent == null || typeof agent !== "object") return;
+  if (isAgentInstance(agent)) return;
+  for (const key of FORBIDDEN_AGENT_KEYS) {
+    if (key in agent) {
+      throw new SecurityError(
+        `"agent.${key}" is not allowed in PlatformAgentConfig. Tools come from "connectors", team members from "team.members". All are platform-managed and injected via the governance gateway.`
+      );
+    }
+  }
+};
+var isPlatformSkill = (v) => v != null && typeof v === "object" && v.__type === "PlatformSkill";
+var isPlatformConnector = (v) => v != null && typeof v === "object" && v.__type === "PlatformConnector";
+var isPlatformAgent = (v) => v != null && typeof v === "object" && v.__type === "PlatformAgent";
+var normalizeSkillRef = (ref) => isPlatformSkill(ref) ? ref.name : ref;
+var normalizeConnectorRef = (ref) => isPlatformConnector(ref) ? ref.name : ref;
+var normalizeTeamMember = (ref) => isPlatformAgent(ref) ? ref.config.agent.name : ref;
+var isPlatformActions = (v) => v != null && typeof v === "object" && v.__type === "PlatformActions";
+var definePlatformAgent = (config) => {
+  assertNoInjection(config.agent);
+  let agentDef;
+  let runtime;
+  let outputSchema;
+  if (isAgentInstance(config.agent)) {
+    agentDef = config.agent.definition;
+    runtime = config.agent;
+  } else {
+    const {
+      outputSchema: os,
+      skills: rawSkills,
+      ...rest
+    } = config.agent;
+    agentDef = {
+      ...rest,
+      skills: rawSkills?.map(normalizeSkillRef)
+    };
+    outputSchema = os;
+  }
+  const normalizedConnectors = config.connectors?.map(normalizeConnectorRef);
+  const normalizedTeam = config.team ? { ...config.team, members: config.team.members.map(normalizeTeamMember) } : void 0;
+  const teamAgents = config.team?.members.filter((m) => isPlatformAgent(m));
+  let actionsConfig;
+  let actionZodSchemas;
+  let actionHandlers;
+  if (config.actions && isPlatformActions(config.actions)) {
+    actionsConfig = config.actions.config;
+    actionZodSchemas = config.actions.zodSchemas;
+    const h = config.actions.handlers;
+    actionHandlers = Object.keys(h).length > 0 ? h : void 0;
+  }
+  const parsed = platformAgentConfigSchema.parse({
+    ...config,
+    agent: agentDef,
+    connectors: normalizedConnectors,
+    team: normalizedTeam,
+    actions: actionsConfig
+  });
+  return {
+    __type: "PlatformAgent",
+    config: parsed,
+    runtime,
+    outputSchema,
+    actionZodSchemas,
+    actionHandlers,
+    teamAgents: teamAgents && teamAgents.length > 0 ? teamAgents : void 0
+  };
+};
+
+// src/agents/define-actions.ts
+var z11 = __toESM(require("zod"), 1);
+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: z11.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]) => z11.object({ action: z11.literal(name) }).extend(schema.shape)
+  );
+  const [first, ...rest] = variants;
+  if (!first) {
+    throw new Error("Cannot build output schema from empty action definitions");
+  }
+  return z11.discriminatedUnion("action", [first, ...rest]);
+};
+
+// src/agents/define-connector.ts
+var defineTool = (def) => def;
+var defineConnector = (input) => {
+  if (!input.name || input.name.length === 0) {
+    throw new Error("Connector name must not be empty");
+  }
+  const tools = input.tools ? Object.freeze({ ...input.tools }) : void 0;
+  const resources = input.resources ? Object.freeze({ ...input.resources }) : void 0;
+  const prompts = input.prompts ? Object.freeze({ ...input.prompts }) : void 0;
+  return Object.freeze({
+    __type: "PlatformConnector",
+    name: input.name,
+    description: input.description,
+    instructions: input.instructions,
+    tools,
+    resources,
+    prompts
+  });
+};
+
+// src/agents/define-skill.ts
+var defineSkill = (input) => {
+  const parsed = platformSkillInputSchema.parse(input);
+  return Object.freeze({
+    __type: "PlatformSkill",
+    name: parsed.name,
+    description: parsed.description
+  });
+};
+
+// src/cli/discover.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+var z12 = __toESM(require("zod"), 1);
+
+// 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
+var MANIFEST_START = "---KRAKEN-MANIFEST-START---";
+var MANIFEST_END = "---KRAKEN-MANIFEST-END---";
+var skillEntrySchema = z12.object({
+  name: z12.string().min(1),
+  path: z12.string().min(1),
+  content: z12.string()
+});
+var connectorEntrySchema = z12.object({
+  name: z12.string().min(1),
+  path: z12.string().min(1)
+});
+var agentEntrySchema = z12.object({
+  name: z12.string().min(1),
+  entryPoint: z12.string().min(1),
+  config: platformAgentConfigSchema
+});
+var projectManifestSchema = z12.object({
+  agents: z12.array(agentEntrySchema),
+  skills: z12.array(skillEntrySchema),
+  connectors: z12.array(connectorEntrySchema)
+});
+var MAX_SKILL_SIZE = 100 * 1024;
+var parseManifestFromOutput = (stdout) => {
+  const startIdx = stdout.indexOf(MANIFEST_START);
+  const endIdx = stdout.indexOf(MANIFEST_END);
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) {
+    throw new Error("Discovery produced no output: sentinel markers not found");
+  }
+  const jsonStr = stdout.slice(startIdx + MANIFEST_START.length, endIdx).trim();
+  let raw;
+  try {
+    raw = JSON.parse(jsonStr);
+  } catch {
+    throw new Error(`Discovery produced invalid JSON: ${jsonStr.slice(0, 200)}`);
+  }
+  const result = projectManifestSchema.safeParse(raw);
+  if (!result.success) {
+    throw new Error(`Discovery produced invalid manifest: ${result.error.message}`);
+  }
+  return result.data;
+};
+
+// src/dev.ts
+var import_node_fs2 = require("fs");
+var import_node_readline = require("readline");
+var import_kraken_ai2 = require("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
+var import_node_path2 = require("path");
+var import_kraken_ai = require("kraken-ai");
+var isPlatformConnector2 = (v) => v != null && typeof v === "object" && v.__type === "PlatformConnector";
+var importConnector = async (name, projectRoot) => {
+  const basePath = (0, import_node_path2.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]) => (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_fs2.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_fs2.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 {};
+  }
+};
+
+// src/platform/http.ts
+var PlatformError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "PlatformError";
+  }
+};
+var HttpClient = class {
+  baseUrlForStream;
+  baseUrl;
+  apiKey;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.baseUrlForStream = this.baseUrl;
+    this.apiKey = config.apiKey;
+    const isLocalhost = this.baseUrl.includes("localhost") || this.baseUrl.includes("127.0.0.1");
+    if (this.baseUrl.startsWith("http://") && !isLocalhost) {
+      console.warn(
+        "[kraken-ai] WARNING: baseUrl does not use HTTPS. API keys will be sent in plaintext."
+      );
+    }
+  }
+  async get(path2, params) {
+    const url = this.buildUrl(path2, params);
+    const response = await fetch(url, {
+      method: "GET",
+      headers: this.authHeaders()
+    });
+    return this.handleResponse(response);
+  }
+  async post(path2, body) {
+    const response = await fetch(this.buildUrl(path2), {
+      method: "POST",
+      headers: { ...this.authHeaders(), "Content-Type": "application/json" },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    return this.handleResponse(response);
+  }
+  async postStream(path2, body, signal) {
+    const response = await fetch(this.buildUrl(path2), {
+      method: "POST",
+      headers: {
+        ...this.authHeaders(),
+        "Content-Type": "application/json",
+        Accept: "text/event-stream"
+      },
+      body: JSON.stringify(body),
+      signal
+    });
+    if (!response.ok) {
+      const err = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new PlatformError(err.error ?? "Unknown error", response.status);
+    }
+    return response;
+  }
+  buildUrl(path2, params) {
+    const url = `${this.baseUrl}${path2}`;
+    if (!params || Object.keys(params).length === 0) return url;
+    const qs = new URLSearchParams(params).toString();
+    return `${url}?${qs}`;
+  }
+  authHeaders() {
+    return { Authorization: `Bearer ${this.apiKey}` };
+  }
+  async handleResponse(response) {
+    if (!response.ok) {
+      const body = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new PlatformError(body.error ?? "Unknown error", response.status);
+    }
+    return response.json();
+  }
+};
+
+// src/platform/sse.ts
+var VALID_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "tool_call",
+  "tool_result",
+  "thinking",
+  "action",
+  "done",
+  "error"
+]);
+async function* parseSSEStream(stream) {
+  const decoder = new TextDecoder();
+  const reader = stream.getReader();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const parts = buffer.split("\n\n");
+      buffer = parts.pop() ?? "";
+      for (const part of parts) {
+        const event = parseBlock(part);
+        if (event) yield event;
+      }
+    }
+    if (buffer.trim()) {
+      const event = parseBlock(buffer);
+      if (event) yield event;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+var parseBlock = (block) => {
+  let eventType = null;
+  let data = null;
+  for (const line of block.split("\n")) {
+    if (line.startsWith(":")) continue;
+    if (line.startsWith("event: ")) {
+      eventType = line.slice(7).trim();
+    } else if (line.startsWith("data: ")) {
+      data = line.slice(6);
+    }
+  }
+  if (!eventType || !data || !VALID_EVENT_TYPES.has(eventType)) return null;
+  try {
+    const parsed = JSON.parse(data);
+    return { type: eventType, ...parsed };
+  } catch {
+    return null;
+  }
+};
+
+// src/platform/agent-handle.ts
+var deferred = () => {
+  let resolve2;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve2 = res;
+    reject = rej;
+  });
+  return { promise, resolve: resolve2, reject };
+};
+var AgentHandle = class {
+  constructor(http, agentId, opts) {
+    this.http = http;
+    this.agentId = agentId;
+    this.threadId = opts?.threadId;
+  }
+  actionHandlers = /* @__PURE__ */ new Map();
+  threadId;
+  onAction(name, handler) {
+    this.actionHandlers.set(name, handler);
+  }
+  async generate(input, opts) {
+    if (!this.threadId) {
+      const info = await this.http.post(`/api/v1/agents/${this.agentId}/threads`);
+      this.threadId = info.id;
+    }
+    const response = await this.http.postStream(
+      `/api/v1/agents/${this.agentId}/threads/${this.threadId}/messages`,
+      { content: typeof input === "string" ? input : JSON.stringify(input) },
+      opts?.signal
+    );
+    if (!response.body) {
+      throw new PlatformError("Response body is empty", 0);
+    }
+    const rawStream = parseSSEStream(response.body);
+    const {
+      promise: resultPromise,
+      resolve: resolveResult,
+      reject: rejectResult
+    } = deferred();
+    const actionHandlers = this.actionHandlers;
+    const http = this.http;
+    const agentId = this.agentId;
+    const threadId = this.threadId;
+    async function* streamWithDispatch() {
+      try {
+        for await (const event of rawStream) {
+          if (event.type === "action") {
+            const handler = actionHandlers.get(event.name);
+            if (handler) {
+              await handler(event.payload);
+            }
+            void http.post(
+              `/api/v1/agents/${agentId}/threads/${threadId}/actions/${event.actionExecutionId}/ack`
+            ).catch(() => {
+            });
+          }
+          if (event.type === "done") {
+            resolveResult(event.output);
+          }
+          if (event.type === "error") {
+            rejectResult(new PlatformError(event.message, 0));
+          }
+          yield event;
+        }
+      } catch (err) {
+        rejectResult(err instanceof Error ? err : new Error(String(err)));
+        throw err;
+      }
+    }
+    let streamGenerator = null;
+    let streamStarted = false;
+    const ensureStream = () => {
+      if (!streamGenerator) {
+        streamGenerator = streamWithDispatch();
+      }
+      return streamGenerator;
+    };
+    const backgroundConsume = async () => {
+      if (streamStarted) return;
+      streamStarted = true;
+      const gen = ensureStream();
+      for await (const _ of gen) {
+        void _;
+      }
+    };
+    const result = {
+      threadId,
+      stream() {
+        streamStarted = true;
+        return ensureStream();
+      },
+      get result() {
+        void backgroundConsume();
+        return resultPromise;
+      }
+    };
+    return result;
+  }
+};
+
+// src/platform/agents.ts
+var AgentThread = class {
+  constructor(http, agentId, threadId) {
+    this.http = http;
+    this.agentId = agentId;
+    this.threadId = threadId;
+  }
+  async sendMessage(content, opts) {
+    const response = await this.http.postStream(
+      `/api/v1/agents/${this.agentId}/threads/${this.threadId}/messages`,
+      { content },
+      opts?.signal
+    );
+    if (!response.body) {
+      throw new PlatformError("Response body is empty", 0);
+    }
+    return parseSSEStream(response.body);
+  }
+  async getMessages(params) {
+    const qs = buildPaginationQuery(params);
+    return this.http.get(`/api/v1/agents/${this.agentId}/threads/${this.threadId}/messages`, qs);
+  }
+};
+var AgentsNamespace = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    const result = await this.http.get("/api/v1/agents");
+    return result.data;
+  }
+  async createThread(agentId) {
+    const info = await this.http.post(`/api/v1/agents/${agentId}/threads`);
+    return new AgentThread(this.http, agentId, info.id);
+  }
+  async getThread(agentId, threadId) {
+    await this.http.get(`/api/v1/agents/${agentId}/threads/${threadId}`);
+    return new AgentThread(this.http, agentId, threadId);
+  }
+  async listThreads(agentId, params) {
+    const qs = buildPaginationQuery(params);
+    return this.http.get(`/api/v1/agents/${agentId}/threads`, qs);
+  }
+};
+var buildPaginationQuery = (params) => {
+  if (!params) return void 0;
+  const qs = {};
+  if (params.cursor) qs.cursor = params.cursor;
+  if (params.limit != null) qs.limit = String(params.limit);
+  return Object.keys(qs).length > 0 ? qs : void 0;
+};
+
+// src/platform/data.ts
+var DataNamespace = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    const result = await this.http.get("/api/v1/data/queries");
+    return result.data;
+  }
+  async describe(queryName) {
+    return this.http.get(`/api/v1/data/queries/${queryName}`);
+  }
+  async query(queryName, params, pagination) {
+    return this.http.post(`/api/v1/data/queries/${queryName}/execute`, {
+      params,
+      ...pagination
+    });
+  }
+};
+
+// src/platform/pipelines.ts
+var z13 = __toESM(require("zod"), 1);
+var PipelinesNamespace = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async query(pipeline, queryName, schema, params) {
+    const result = await this.http.post(
+      `/api/v1/pipelines/${encodeURIComponent(pipeline)}/queries/${encodeURIComponent(queryName)}`,
+      params
+    );
+    try {
+      return z13.array(schema.returns).parse(result.rows);
+    } catch (e) {
+      throw new Error(
+        `Pipeline schema may have changed \u2014 run 'kraken generate' to update types.
+
+Original error: ${e.message}`
+      );
+    }
+  }
+};
+
+// src/platform/runs.ts
+var RunsNamespace = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async start(params) {
+    return this.http.post("/api/v1/runs", params);
+  }
+  async get(runId) {
+    return this.http.get(`/api/v1/runs/${runId}`);
+  }
+  async cancel(runId) {
+    return this.http.post(`/api/v1/runs/${runId}/cancel`);
+  }
+  async getEvents(runId, opts) {
+    const params = opts?.afterEventId ? { afterEventId: opts.afterEventId } : void 0;
+    return this.http.get(`/api/v1/runs/${runId}/events`, params);
+  }
+  async *streamEvents(runId, opts) {
+    const response = await fetch(
+      `${this.http.baseUrlForStream}/api/v1/runs/${runId}/events/stream`,
+      {
+        headers: {
+          Accept: "text/event-stream",
+          ...this.http.authHeaders()
+        },
+        signal: opts?.signal
+      }
+    );
+    if (!response.ok || !response.body) {
+      throw new PlatformError("Failed to connect to event stream", response.status);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const raw = line.slice(6).trim();
+          if (!raw || raw === "[DONE]") continue;
+          try {
+            yield JSON.parse(raw);
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.cancel();
+    }
+  }
+};
+
+// src/platform/client.ts
+var PlatformClient = class {
+  agents;
+  data;
+  pipelines;
+  runs;
+  http;
+  constructor(config) {
+    if (!config.baseUrl) throw new Error("baseUrl is required");
+    if (!config.apiKey) throw new Error("apiKey is required");
+    this.http = new HttpClient(config);
+    this.agents = new AgentsNamespace(this.http);
+    this.data = new DataNamespace(this.http);
+    this.pipelines = new PipelinesNamespace(this.http);
+    this.runs = new RunsNamespace(this.http);
+  }
+  agent(id, opts) {
+    if (opts?.mode === "local") {
+      throw new PlatformError("Local mode not yet implemented", 0);
+    }
+    return new AgentHandle(this.http, id, {
+      threadId: opts?.threadId
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACTION_NAME_REGEX,
+  AgentHandle,
+  AgentThread,
+  ConnectorError,
+  MANIFEST_END,
+  MANIFEST_START,
+  MockToolSet,
+  PlatformClient,
+  PlatformError,
+  SecurityError,
+  actionVariantConfigSchema,
+  actionsConfigSchema,
+  agentDefinitionSchema,
+  buildActionOutputSchema,
+  concurrencyPolicySchema,
+  defineAction,
+  defineActions,
+  defineConnector,
+  definePlatformAgent,
+  defineSkill,
+  defineTool,
+  environmentSchema,
+  identityConfigSchema,
+  isValidActionName,
+  jitPolicySchema,
+  mcpResult,
+  notificationConfigSchema,
+  parseManifestFromOutput,
+  platformAgentConfigSchema,
+  projectManifestSchema,
+  resourceLimitsSchema,
+  retryPolicySchema,
+  runDev,
+  teamConfigSchema,
+  triggerConfigSchema,
+  wrapToolError,
+  wrapToolResult
+});
+//# sourceMappingURL=index.cjs.map