@kraken-ai/platform 0.0.4 → 0.0.6

package/dist/index.cjs

@@ -39,41 +39,24 @@ __export(index_exports, {
   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,
+  isQualified: () => isQualified,
   isValidActionName: () => isValidActionName,
-  jitPolicySchema: () => jitPolicySchema,
   mcpResult: () => mcpResult,
-  notificationConfigSchema: () => notificationConfigSchema,
+  parse: () => parse,
   parseManifestFromOutput: () => parseManifestFromOutput,
-  platformAgentConfigSchema: () => platformAgentConfigSchema,
-  projectManifestSchema: () => projectManifestSchema,
-  resourceLimitsSchema: () => resourceLimitsSchema,
-  retryPolicySchema: () => retryPolicySchema,
-  teamConfigSchema: () => teamConfigSchema,
-  triggerConfigSchema: () => triggerConfigSchema,
+  qualify: () => qualify,
   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
+// ../../../private-packages/platform-core/dist/errors.js
 var SecurityError = class extends Error {
   code = "SECURITY_VIOLATION";
   constructor(message) {
@@ -89,6 +72,221 @@ var ConnectorError = class extends Error {
   }
 };
 
+// ../../../private-packages/platform-core/dist/qualified-name.js
+var qualify = (repoName, primitiveName) => {
+  if (!repoName)
+    throw new Error("repoName must not be empty");
+  if (!primitiveName)
+    throw new Error("primitiveName must not be empty");
+  return `${repoName}/${primitiveName}`;
+};
+var parse = (qualified) => {
+  const slashIndex = qualified.indexOf("/");
+  if (slashIndex === -1) {
+    throw new Error(`Expected qualified name with "/" separator, got: "${qualified}"`);
+  }
+  if (qualified.indexOf("/", slashIndex + 1) !== -1) {
+    throw new Error(`Expected exactly one "/" in qualified name, got: "${qualified}"`);
+  }
+  const repoName = qualified.slice(0, slashIndex);
+  const primitiveName = qualified.slice(slashIndex + 1);
+  if (!repoName || !primitiveName) {
+    throw new Error(`Both repo and primitive segments must be non-empty, got: "${qualified}"`);
+  }
+  return { repoName, primitiveName };
+};
+var isQualified = (name) => {
+  const slashIndex = name.indexOf("/");
+  if (slashIndex === -1 || slashIndex === 0 || slashIndex === name.length - 1)
+    return false;
+  return name.indexOf("/", slashIndex + 1) === -1;
+};
+
+// ../../../private-packages/platform-core/dist/types/action.js
+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);
+
+// ../../../private-packages/platform-core/dist/types/environment.js
+var z = __toESM(require("zod"), 1);
+var environmentSchema = z.enum(["dev", "staging", "prod"]);
+
+// ../../../private-packages/platform-core/dist/types/identity.js
+var z2 = __toESM(require("zod"), 1);
+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: z2.number().int().positive().optional()
+});
+
+// ../../../private-packages/platform-core/dist/types/notifications.js
+var z3 = __toESM(require("zod"), 1);
+var notificationConfigSchema = z3.object({
+  slack: z3.string().optional(),
+  onSuccess: z3.boolean().optional(),
+  onFailure: z3.boolean().optional(),
+  onTimeout: z3.boolean().optional()
+});
+
+// ../../../private-packages/platform-core/dist/types/platform-agent.js
+var z7 = __toESM(require("zod"), 1);
+
+// ../../../private-packages/platform-core/dist/validate.js
+var PRIMITIVE_NAME_REGEX = /^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]$/;
+var isValidPrimitiveName = (name) => name.length === 1 ? /^[a-z0-9]$/.test(name) : PRIMITIVE_NAME_REGEX.test(name);
+var SKILL_NAME_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9-]{0,62}[a-zA-Z0-9]$/;
+var isValidSkillName = (basename) => basename.length === 1 ? /^[a-zA-Z0-9]$/.test(basename) : SKILL_NAME_REGEX.test(basename);
+var isValidSkillId = (id) => {
+  const base = id.endsWith(".md") ? id.slice(0, -3) : id;
+  return isValidSkillName(base);
+};
+var isValidQualifiedName = (name) => {
+  if (!isQualified(name))
+    return false;
+  const { repoName, primitiveName } = parse(name);
+  return isValidPrimitiveName(repoName) && isValidPrimitiveName(primitiveName);
+};
+var isValidQualifiedSkillId = (id) => {
+  if (!isQualified(id))
+    return false;
+  const { repoName, primitiveName } = parse(id);
+  return isValidPrimitiveName(repoName) && isValidSkillId(primitiveName);
+};
+
+// ../../../private-packages/platform-core/dist/types/resources.js
+var z4 = __toESM(require("zod"), 1);
+var resourceLimitsSchema = z4.object({
+  maxTokens: z4.number().int().positive().optional(),
+  maxCostUsd: z4.number().positive().optional(),
+  timeoutSeconds: z4.number().int().positive().optional()
+});
+var retryPolicySchema = z4.object({
+  maxAttempts: z4.number().int().min(1).optional(),
+  backoffSeconds: z4.number().positive().optional()
+});
+var concurrencyPolicySchema = z4.object({
+  maxParallelRuns: z4.number().int().min(1).optional()
+});
+
+// ../../../private-packages/platform-core/dist/types/team.js
+var z5 = __toESM(require("zod"), 1);
+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()
+});
+
+// ../../../private-packages/platform-core/dist/types/trigger.js
+var z6 = __toESM(require("zod"), 1);
+var cronTriggerSchema = z6.object({
+  type: z6.literal("cron"),
+  expression: z6.string(),
+  timezone: z6.string().optional()
+});
+var webhookTriggerSchema = z6.object({
+  type: z6.literal("webhook"),
+  path: z6.string().startsWith("/"),
+  method: z6.enum(["POST", "GET"]).optional()
+});
+var eventTriggerSchema = z6.object({
+  type: z6.literal("event"),
+  source: z6.string(),
+  event: z6.string()
+});
+var apiTriggerSchema = z6.object({ type: z6.literal("api") });
+var manualTriggerSchema = z6.object({ type: z6.literal("manual") });
+var triggerConfigSchema = z6.discriminatedUnion("type", [
+  cronTriggerSchema,
+  webhookTriggerSchema,
+  eventTriggerSchema,
+  apiTriggerSchema,
+  manualTriggerSchema
+]);
+
+// ../../../private-packages/platform-core/dist/types/platform-agent.js
+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 = z7.object({
+  agent: agentDefinitionSchema,
+  connectors: z7.array(z7.string()).optional(),
+  triggers: z7.array(triggerConfigSchema),
+  identity: identityConfigSchema.optional(),
+  resources: resourceLimitsSchema.optional(),
+  retries: retryPolicySchema.optional(),
+  concurrency: concurrencyPolicySchema.optional(),
+  team: teamConfigSchema.optional(),
+  notifications: notificationConfigSchema.optional(),
+  environment: environmentSchema.optional(),
+  actions: z7.array(z7.string()).optional()
+}).strict().superRefine((data, ctx) => {
+  for (const member of data.team?.members ?? []) {
+    const valid = isQualified(member) ? isValidQualifiedName(member) : isValidPrimitiveName(member);
+    if (!valid) {
+      ctx.addIssue({
+        code: z7.ZodIssueCode.custom,
+        path: ["team", "members"],
+        message: `Invalid team member name: "${member}"`
+      });
+    }
+  }
+  for (const connector of data.connectors ?? []) {
+    const valid = isQualified(connector) ? isValidQualifiedName(connector) : isValidPrimitiveName(connector);
+    if (!valid) {
+      ctx.addIssue({
+        code: z7.ZodIssueCode.custom,
+        path: ["connectors"],
+        message: `Invalid connector name: "${connector}"`
+      });
+    }
+  }
+  for (const skill of data.agent.skills ?? []) {
+    const valid = isQualified(skill) ? isValidQualifiedSkillId(skill) : isValidSkillId(skill);
+    if (!valid) {
+      ctx.addIssue({
+        code: z7.ZodIssueCode.custom,
+        path: ["agent", "skills"],
+        message: `Invalid skill ID: "${skill}"`
+      });
+    }
+  }
+  for (const action of data.actions ?? []) {
+    const valid = isQualified(action) ? isValidQualifiedName(action) : isValidPrimitiveName(action);
+    if (!valid) {
+      ctx.addIssue({
+        code: z7.ZodIssueCode.custom,
+        path: ["actions"],
+        message: `Invalid action name: "${action}"`
+      });
+    }
+  }
+});
+
+// ../../../private-packages/platform-core/dist/types/skill.js
+var z8 = __toESM(require("zod"), 1);
+var platformSkillInputSchema = z8.object({
+  name: z8.string().min(1),
+  description: z8.string().optional()
+}).strict();
+
+// src/agents/connector-server.ts
+var import_node_crypto = require("crypto");
+var import_node_http = require("http");
+var z9 = __toESM(require("zod"), 1);
+
 // 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;
@@ -144,132 +342,6 @@ var mcpResult = (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(),
-  triggers: z9.array(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";
@@ -290,7 +362,8 @@ var isPlatformAgent = (v) => v != null && typeof v === "object" && v.__type ===
 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 isPlatformAction = (v) => v != null && typeof v === "object" && v.__type === "PlatformAction";
+var normalizeActionRef = (ref) => isPlatformAction(ref) ? ref.name : ref;
 var definePlatformAgent = (config) => {
   assertNoInjection(config.agent);
   let agentDef;
@@ -301,7 +374,7 @@ var definePlatformAgent = (config) => {
     runtime = config.agent;
   } else {
     const {
-      outputSchema: os,
+      outputSchema: os2,
       skills: rawSkills,
       ...rest
     } = config.agent;
@@ -309,26 +382,39 @@ var definePlatformAgent = (config) => {
       ...rest,
       skills: rawSkills?.map(normalizeSkillRef)
     };
-    outputSchema = os;
+    outputSchema = os2;
   }
   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;
+  const actionObjects = config.actions?.filter((a) => isPlatformAction(a));
+  const normalizedActions = config.actions?.map(normalizeActionRef);
   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;
+  let actionWebhooks;
+  if (actionObjects && actionObjects.length > 0) {
+    const schemas = {};
+    const handlers = {};
+    const webhooks = {};
+    for (const action of actionObjects) {
+      schemas[action.name] = action.zodSchema;
+      if (action.handler) {
+        handlers[action.name] = action.handler;
+      }
+      if (action.config.webhook) {
+        webhooks[action.name] = action.config.webhook;
+      }
+    }
+    actionZodSchemas = Object.freeze(schemas);
+    actionHandlers = Object.keys(handlers).length > 0 ? Object.freeze(handlers) : void 0;
+    actionWebhooks = Object.keys(webhooks).length > 0 ? Object.freeze(webhooks) : void 0;
   }
   const parsed = platformAgentConfigSchema.parse({
     ...config,
     agent: agentDef,
     connectors: normalizedConnectors,
     team: normalizedTeam,
-    actions: actionsConfig
+    actions: normalizedActions
   });
   return {
     __type: "PlatformAgent",
@@ -337,61 +423,43 @@ var definePlatformAgent = (config) => {
     outputSchema,
     actionZodSchemas,
     actionHandlers,
+    actionWebhooks,
     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;
-    }
+var z10 = __toESM(require("zod"), 1);
+var defineAction = (input) => {
+  if (!input.name || !isValidActionName(input.name)) {
+    throw new Error(
+      `Invalid action name "${input.name}": must be lowercase alphanumeric with hyphens, 1-64 chars`
+    );
   }
   return Object.freeze({
-    __type: "PlatformActions",
-    config: Object.freeze({ variants: Object.freeze(serialized) }),
-    zodSchemas: Object.freeze(zodSchemas),
-    handlers: Object.freeze(handlers)
+    __type: "PlatformAction",
+    name: input.name,
+    config: Object.freeze({
+      schema: z10.toJSONSchema(input.schema, { target: "draft-2020-12" }),
+      webhook: input.webhook,
+      hasHandler: !!input.handler
+    }),
+    zodSchema: input.schema,
+    handler: input.handler
   });
 };
 var buildActionOutputSchema = (actions) => {
-  const entries = Object.entries(actions.zodSchemas);
-  if (entries.length === 0) {
+  if (actions.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 variants = actions.map(
+    (action) => z10.object({ action: z10.literal(action.name) }).extend(action.zodSchema.shape)
   );
   const [first, ...rest] = variants;
   if (!first) {
     throw new Error("Cannot build output schema from empty action definitions");
   }
-  return z11.discriminatedUnion("action", [first, ...rest]);
+  return z10.discriminatedUnion("action", [first, ...rest]);
 };
 
 // src/agents/define-connector.ts
@@ -426,9 +494,10 @@ var defineSkill = (input) => {
 
 // src/cli/discover.ts
 var import_node_fs = __toESM(require("fs"), 1);
+var import_node_module = require("module");
 var import_node_path = __toESM(require("path"), 1);
 var import_node_url = require("url");
-var z12 = __toESM(require("zod"), 1);
+var z11 = __toESM(require("zod"), 1);
 
 // src/cli/log.ts
 var supportsColor = !("NO_COLOR" in process.env) && process.env.FORCE_COLOR !== "0" && (process.stderr.isTTY ?? false);
@@ -447,24 +516,65 @@ var cyan = code(36, 39);
 // 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 skillEntrySchema = z11.object({
+  name: z11.string().min(1),
+  path: z11.string().min(1),
+  content: z11.string()
+});
+var toolSpecSchema = z11.object({
+  name: z11.string(),
+  description: z11.string(),
+  parameters: z11.record(z11.string(), z11.unknown()).default({}),
+  annotations: z11.object({
+    readOnlyHint: z11.boolean().optional(),
+    destructiveHint: z11.boolean().optional(),
+    idempotentHint: z11.boolean().optional()
+  }).optional()
 });
-var connectorEntrySchema = z12.object({
-  name: z12.string().min(1),
-  path: z12.string().min(1)
+var resourceSpecSchema = z11.object({
+  name: z11.string(),
+  uri: z11.string(),
+  description: z11.string(),
+  mimeType: z11.string().optional()
 });
-var agentEntrySchema = z12.object({
-  name: z12.string().min(1),
-  entryPoint: z12.string().min(1),
+var promptSpecSchema = z11.object({
+  name: z11.string(),
+  description: z11.string(),
+  arguments: z11.array(
+    z11.object({
+      name: z11.string(),
+      description: z11.string().optional(),
+      required: z11.boolean().optional()
+    })
+  ).optional()
+});
+var connectorEntrySchema = z11.object({
+  name: z11.string().min(1),
+  path: z11.string().min(1),
+  toolSpecs: z11.array(toolSpecSchema).default([]),
+  resourceSpecs: z11.array(resourceSpecSchema).default([]),
+  promptSpecs: z11.array(promptSpecSchema).default([])
+});
+var agentEntrySchema = z11.object({
+  name: z11.string().min(1),
+  entryPoint: z11.string().min(1),
   config: platformAgentConfigSchema
 });
-var projectManifestSchema = z12.object({
-  agents: z12.array(agentEntrySchema),
-  skills: z12.array(skillEntrySchema),
-  connectors: z12.array(connectorEntrySchema)
+var actionConfigSchema = z11.object({
+  schema: z11.record(z11.string(), z11.unknown()),
+  webhook: z11.string().url().optional(),
+  hasHandler: z11.boolean()
+});
+var actionEntrySchema = z11.object({
+  name: z11.string().min(1),
+  entryPoint: z11.string().min(1),
+  config: actionConfigSchema
+});
+var projectManifestSchema = z11.object({
+  agents: z11.array(agentEntrySchema),
+  skills: z11.array(skillEntrySchema),
+  connectors: z11.array(connectorEntrySchema),
+  actions: z11.array(actionEntrySchema).default([])
 });
 var MAX_SKILL_SIZE = 100 * 1024;
 var parseManifestFromOutput = (stdout) => {
@@ -487,6 +597,31 @@ var parseManifestFromOutput = (stdout) => {
   return result.data;
 };
 
+// src/internal/secret-string.ts
+var import_node_util = require("util");
+var SecretString = class {
+  #value;
+  constructor(value) {
+    this.#value = value;
+  }
+  unmasked() {
+    return this.#value;
+  }
+  toJSON() {
+    return "[REDACTED]";
+  }
+  toString() {
+    return "[REDACTED]";
+  }
+  [Symbol.toPrimitive]() {
+    return "[REDACTED]";
+  }
+  [import_node_util.inspect.custom]() {
+    return "SecretString([REDACTED])";
+  }
+};
+var unwrapSecret = (value) => value instanceof SecretString ? value.unmasked() : value;
+
 // src/platform/http.ts
 var PlatformError = class extends Error {
   constructor(message, status) {
@@ -494,6 +629,7 @@ var PlatformError = class extends Error {
     this.status = status;
     this.name = "PlatformError";
   }
+  status;
 };
 var HttpClient = class {
   baseUrlForStream;
@@ -502,7 +638,7 @@ var HttpClient = class {
   constructor(config) {
     this.baseUrl = config.baseUrl.replace(/\/+$/, "");
     this.baseUrlForStream = this.baseUrl;
-    this.apiKey = config.apiKey;
+    this.apiKey = new SecretString(config.apiKey);
     const isLocalhost = this.baseUrl.includes("localhost") || this.baseUrl.includes("127.0.0.1");
     if (this.baseUrl.startsWith("http://") && !isLocalhost) {
       console.warn(
@@ -510,24 +646,24 @@ var HttpClient = class {
       );
     }
   }
-  async get(path2, params) {
-    const url = this.buildUrl(path2, params);
+  async get(path3, params) {
+    const url = this.buildUrl(path3, 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), {
+  async post(path3, body) {
+    const response = await fetch(this.buildUrl(path3), {
       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), {
+  async postStream(path3, body, signal) {
+    const response = await fetch(this.buildUrl(path3), {
       method: "POST",
       headers: {
         ...this.authHeaders(),
@@ -543,14 +679,14 @@ var HttpClient = class {
     }
     return response;
   }
-  buildUrl(path2, params) {
-    const url = `${this.baseUrl}${path2}`;
+  buildUrl(path3, params) {
+    const url = `${this.baseUrl}${path3}`;
     if (!params || Object.keys(params).length === 0) return url;
     const qs = new URLSearchParams(params).toString();
     return `${url}?${qs}`;
   }
   authHeaders() {
-    return { Authorization: `Bearer ${this.apiKey}` };
+    return { Authorization: `Bearer ${unwrapSecret(this.apiKey)}` };
   }
   async handleResponse(response) {
     if (!response.ok) {
@@ -631,6 +767,8 @@ var AgentHandle = class {
     this.agentId = agentId;
     this.threadId = opts?.threadId;
   }
+  http;
+  agentId;
   actionHandlers = /* @__PURE__ */ new Map();
   threadId;
   onAction(name, handler) {
@@ -723,6 +861,9 @@ var AgentThread = class {
     this.agentId = agentId;
     this.threadId = threadId;
   }
+  http;
+  agentId;
+  threadId;
   async sendMessage(content, opts) {
     const response = await this.http.postStream(
       `/api/v1/agents/${this.agentId}/threads/${this.threadId}/messages`,
@@ -743,6 +884,7 @@ var AgentsNamespace = class {
   constructor(http) {
     this.http = http;
   }
+  http;
   async list() {
     const result = await this.http.get("/api/v1/agents");
     return result.data;
@@ -768,11 +910,39 @@ var buildPaginationQuery = (params) => {
   return Object.keys(qs).length > 0 ? qs : void 0;
 };
 
+// src/cli/credentials.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var credentialsDir = () => import_node_path2.default.join(import_node_os.default.homedir(), ".kraken-ai");
+var credentialsPath = () => import_node_path2.default.join(credentialsDir(), "credentials.json");
+var loadCredentials = () => {
+  const filePath = credentialsPath();
+  let creds = null;
+  if (import_node_fs2.default.existsSync(filePath)) {
+    try {
+      creds = JSON.parse(import_node_fs2.default.readFileSync(filePath, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  const envKey = process.env.KRAKEN_API_KEY;
+  const envUrl = process.env.KRAKEN_BASE_URL;
+  if (envKey || envUrl) {
+    return {
+      apiKey: envKey ?? creds?.apiKey ?? "",
+      baseUrl: envUrl ?? creds?.baseUrl ?? ""
+    };
+  }
+  return creds;
+};
+
 // src/platform/data.ts
 var DataNamespace = class {
   constructor(http) {
     this.http = http;
   }
+  http;
   async list() {
     const result = await this.http.get("/api/v1/data/queries");
     return result.data;
@@ -789,18 +959,19 @@ var DataNamespace = class {
 };
 
 // src/platform/pipelines.ts
-var z13 = __toESM(require("zod"), 1);
+var z12 = __toESM(require("zod"), 1);
 var PipelinesNamespace = class {
   constructor(http) {
     this.http = 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);
+      return z12.array(schema.returns).parse(result.rows);
     } catch (e) {
       throw new Error(
         `Pipeline schema may have changed \u2014 run 'kraken generate' to update types.
@@ -816,6 +987,7 @@ var RunsNamespace = class {
   constructor(http) {
     this.http = http;
   }
+  http;
   async start(params) {
     return this.http.post("/api/v1/runs", params);
   }
@@ -870,6 +1042,22 @@ var RunsNamespace = class {
 };
 
 // src/platform/client.ts
+var resolveConfig = (config) => {
+  const creds = loadCredentials();
+  const baseUrl = config?.baseUrl ?? creds?.baseUrl;
+  const apiKey = config?.apiKey ?? creds?.apiKey;
+  if (!baseUrl) {
+    throw new Error(
+      "No Kraken platform endpoint configured.\n\nEither:\n  1. Log in via the CLI:              npx kraken login\n  2. Set the environment variable:    export KRAKEN_BASE_URL=https://your-platform-url\n  3. Pass baseUrl to PlatformClient:  new PlatformClient({ baseUrl: '...' })\n"
+    );
+  }
+  if (!apiKey) {
+    throw new Error(
+      "No Kraken API key configured.\n\nEither:\n  1. Log in via the CLI:              npx kraken login\n  2. Set the environment variable:    export KRAKEN_API_KEY=your-api-key\n  3. Pass apiKey to PlatformClient:   new PlatformClient({ apiKey: '...' })\n"
+    );
+  }
+  return { baseUrl, apiKey };
+};
 var PlatformClient = class {
   agents;
   data;
@@ -877,9 +1065,8 @@ var PlatformClient = class {
   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);
+    const resolved = resolveConfig(config);
+    this.http = new HttpClient(resolved);
     this.agents = new AgentsNamespace(this.http);
     this.data = new DataNamespace(this.http);
     this.pipelines = new PipelinesNamespace(this.http);
@@ -905,30 +1092,18 @@ var PlatformClient = class {
   PlatformClient,
   PlatformError,
   SecurityError,
-  actionVariantConfigSchema,
-  actionsConfigSchema,
-  agentDefinitionSchema,
   buildActionOutputSchema,
-  concurrencyPolicySchema,
   defineAction,
-  defineActions,
   defineConnector,
   definePlatformAgent,
   defineSkill,
   defineTool,
-  environmentSchema,
-  identityConfigSchema,
+  isQualified,
   isValidActionName,
-  jitPolicySchema,
   mcpResult,
-  notificationConfigSchema,
+  parse,
   parseManifestFromOutput,
-  platformAgentConfigSchema,
-  projectManifestSchema,
-  resourceLimitsSchema,
-  retryPolicySchema,
-  teamConfigSchema,
-  triggerConfigSchema,
+  qualify,
   wrapToolError,
   wrapToolResult
 });