@kraken-ai/platform 0.0.4 → 0.0.6

package/dist/index.js

@@ -2,129 +2,18 @@ import {
   ACTION_NAME_REGEX,
   ConnectorError,
   SecurityError,
-  actionVariantConfigSchema,
-  actionsConfigSchema,
   buildActionOutputSchema,
   defineAction,
-  defineActions,
+  isQualified,
   isValidActionName,
   mcpResult,
+  parse,
+  platformAgentConfigSchema,
+  platformSkillInputSchema,
+  qualify,
   wrapToolError,
   wrapToolResult
-} from "./chunk-PPT6GGYL.js";
-
-// src/agents/types/environment.ts
-import * as z from "zod";
-var environmentSchema = z.enum(["dev", "staging", "prod"]);
-
-// src/agents/types/identity.ts
-import * as z2 from "zod";
-var jitPolicySchema = z2.enum(["auto-approve", "policy-based", "require-approval"]);
-var identityConfigSchema = z2.object({
-  basePermissions: z2.array(z2.string()),
-  requestablePermissions: z2.array(z2.string()).optional(),
-  jitPolicy: jitPolicySchema.optional(),
-  maxJitDurationMinutes: z2.number().int().positive().optional()
-});
-
-// src/agents/types/notifications.ts
-import * as z3 from "zod";
-var notificationConfigSchema = z3.object({
-  slack: z3.string().optional(),
-  onSuccess: z3.boolean().optional(),
-  onFailure: z3.boolean().optional(),
-  onTimeout: z3.boolean().optional()
-});
-
-// src/agents/types/platform-agent.ts
-import * as z7 from "zod";
-
-// src/agents/types/resources.ts
-import * as z4 from "zod";
-var resourceLimitsSchema = z4.object({
-  maxTokens: z4.number().int().positive().optional(),
-  maxCostUsd: z4.number().positive().optional(),
-  timeoutSeconds: z4.number().int().positive().optional()
-});
-var retryPolicySchema = 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()
-});
-
-// src/agents/types/team.ts
-import * as z5 from "zod";
-var teamConfigSchema = z5.object({
-  members: z5.array(z5.string()).min(1),
-  maxConcurrentWorkers: z5.number().int().min(1).optional(),
-  maxTokenBudgetPerWorker: z5.number().int().positive().optional(),
-  maxDurationPerWorker: z5.number().positive().optional()
-});
-
-// src/agents/types/trigger.ts
-import * as z6 from "zod";
-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
-]);
-
-// src/agents/types/platform-agent.ts
-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: actionsConfigSchema.optional()
-}).strict();
-
-// src/agents/types/skill.ts
-import * as z8 from "zod";
-var platformSkillInputSchema = z8.object({
-  name: z8.string().min(1),
-  description: z8.string().optional()
-}).strict();
+} from "./chunk-SL6WL3X6.js";
 
 // src/agents/define.ts
 var FORBIDDEN_AGENT_KEYS = ["tools", "team", "kernel"];
@@ -146,7 +35,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;
@@ -157,7 +47,7 @@ var definePlatformAgent = (config) => {
     runtime = config.agent;
   } else {
     const {
-      outputSchema: os,
+      outputSchema: os2,
       skills: rawSkills,
       ...rest
     } = config.agent;
@@ -165,26 +55,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",
@@ -193,6 +96,7 @@ var definePlatformAgent = (config) => {
     outputSchema,
     actionZodSchemas,
     actionHandlers,
+    actionWebhooks,
     teamAgents: teamAgents && teamAgents.length > 0 ? teamAgents : void 0
   };
 };
@@ -229,29 +133,71 @@ var defineSkill = (input) => {
 
 // src/cli/discover.ts
 import fs from "fs";
+import { createRequire } from "module";
 import path from "path";
 import { pathToFileURL } from "url";
-import * as z9 from "zod";
+import * as z from "zod";
 var MANIFEST_START = "---KRAKEN-MANIFEST-START---";
 var MANIFEST_END = "---KRAKEN-MANIFEST-END---";
-var skillEntrySchema = z9.object({
-  name: z9.string().min(1),
-  path: z9.string().min(1),
-  content: z9.string()
+var skillEntrySchema = z.object({
+  name: z.string().min(1),
+  path: z.string().min(1),
+  content: z.string()
+});
+var toolSpecSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  parameters: z.record(z.string(), z.unknown()).default({}),
+  annotations: z.object({
+    readOnlyHint: z.boolean().optional(),
+    destructiveHint: z.boolean().optional(),
+    idempotentHint: z.boolean().optional()
+  }).optional()
 });
-var connectorEntrySchema = z9.object({
-  name: z9.string().min(1),
-  path: z9.string().min(1)
+var resourceSpecSchema = z.object({
+  name: z.string(),
+  uri: z.string(),
+  description: z.string(),
+  mimeType: z.string().optional()
 });
-var agentEntrySchema = z9.object({
-  name: z9.string().min(1),
-  entryPoint: z9.string().min(1),
+var promptSpecSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  arguments: z.array(
+    z.object({
+      name: z.string(),
+      description: z.string().optional(),
+      required: z.boolean().optional()
+    })
+  ).optional()
+});
+var connectorEntrySchema = z.object({
+  name: z.string().min(1),
+  path: z.string().min(1),
+  toolSpecs: z.array(toolSpecSchema).default([]),
+  resourceSpecs: z.array(resourceSpecSchema).default([]),
+  promptSpecs: z.array(promptSpecSchema).default([])
+});
+var agentEntrySchema = z.object({
+  name: z.string().min(1),
+  entryPoint: z.string().min(1),
   config: platformAgentConfigSchema
 });
-var projectManifestSchema = z9.object({
-  agents: z9.array(agentEntrySchema),
-  skills: z9.array(skillEntrySchema),
-  connectors: z9.array(connectorEntrySchema)
+var actionConfigSchema = z.object({
+  schema: z.record(z.string(), z.unknown()),
+  webhook: z.string().url().optional(),
+  hasHandler: z.boolean()
+});
+var actionEntrySchema = z.object({
+  name: z.string().min(1),
+  entryPoint: z.string().min(1),
+  config: actionConfigSchema
+});
+var projectManifestSchema = z.object({
+  agents: z.array(agentEntrySchema),
+  skills: z.array(skillEntrySchema),
+  connectors: z.array(connectorEntrySchema),
+  actions: z.array(actionEntrySchema).default([])
 });
 var MAX_SKILL_SIZE = 100 * 1024;
 var parseManifestFromOutput = (stdout) => {
@@ -274,6 +220,31 @@ var parseManifestFromOutput = (stdout) => {
   return result.data;
 };
 
+// src/internal/secret-string.ts
+import { inspect } from "util";
+var SecretString = class {
+  #value;
+  constructor(value) {
+    this.#value = value;
+  }
+  unmasked() {
+    return this.#value;
+  }
+  toJSON() {
+    return "[REDACTED]";
+  }
+  toString() {
+    return "[REDACTED]";
+  }
+  [Symbol.toPrimitive]() {
+    return "[REDACTED]";
+  }
+  [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) {
@@ -281,6 +252,7 @@ var PlatformError = class extends Error {
     this.status = status;
     this.name = "PlatformError";
   }
+  status;
 };
 var HttpClient = class {
   baseUrlForStream;
@@ -289,7 +261,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(
@@ -297,24 +269,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(),
@@ -330,14 +302,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) {
@@ -418,6 +390,8 @@ var AgentHandle = class {
     this.agentId = agentId;
     this.threadId = opts?.threadId;
   }
+  http;
+  agentId;
   actionHandlers = /* @__PURE__ */ new Map();
   threadId;
   onAction(name, handler) {
@@ -510,6 +484,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`,
@@ -530,6 +507,7 @@ var AgentsNamespace = class {
   constructor(http) {
     this.http = http;
   }
+  http;
   async list() {
     const result = await this.http.get("/api/v1/agents");
     return result.data;
@@ -555,11 +533,39 @@ var buildPaginationQuery = (params) => {
   return Object.keys(qs).length > 0 ? qs : void 0;
 };
 
+// src/cli/credentials.ts
+import fs2 from "fs";
+import os from "os";
+import path2 from "path";
+var credentialsDir = () => path2.join(os.homedir(), ".kraken-ai");
+var credentialsPath = () => path2.join(credentialsDir(), "credentials.json");
+var loadCredentials = () => {
+  const filePath = credentialsPath();
+  let creds = null;
+  if (fs2.existsSync(filePath)) {
+    try {
+      creds = JSON.parse(fs2.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;
@@ -576,18 +582,19 @@ var DataNamespace = class {
 };
 
 // src/platform/pipelines.ts
-import * as z10 from "zod";
+import * as z2 from "zod";
 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 z10.array(schema.returns).parse(result.rows);
+      return z2.array(schema.returns).parse(result.rows);
     } catch (e) {
       throw new Error(
         `Pipeline schema may have changed \u2014 run 'kraken generate' to update types.
@@ -603,6 +610,7 @@ var RunsNamespace = class {
   constructor(http) {
     this.http = http;
   }
+  http;
   async start(params) {
     return this.http.post("/api/v1/runs", params);
   }
@@ -657,6 +665,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;
@@ -664,9 +688,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);
@@ -691,30 +714,18 @@ export {
   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
 };