@kraken-ai/platform 0.0.4 → 0.0.7

package/dist/index.d.cts

@@ -1,441 +1,1180 @@
-import { M as McpContent, P as PlatformConnector, C as ConnectorId, S as SkillId, a as PlatformAgentConfig, T as TeamMember, b as PlatformActions, c as PlatformAgent, A as ActionVariantInput, d as ConnectorDefinition, e as ConnectorToolDef, f as PlatformClientConfig, g as AgentEvent, h as PaginationParams, i as PaginatedResponse, j as ThreadMessage, k as AgentInfo, l as ThreadInfo, Q as QueryInfo, m as QueryResult, n as StartRunParams, R as RunRecord, o as RunEvent } from './types-_lfbhFJH.cjs';
-export { p as ACTION_NAME_REGEX, q as ActionVariantConfig, r as AgentDefinition, s as AgentId, t as AgentSchema, u as ConnectorHandlerContext, v as ConnectorHandlerResult, w as ConnectorPromptDef, x as ConnectorResourceDef, y as ConnectorSchema, G as GetPromptResult, K as KrakenTypeRegistry, z as PlatformActionsConfig, B as PromptMessageContent, D as QueryColumn, E as QuerySchema, F as ReadResourceResult, H as ResourceContent, I as RunState, J as SkillSchema, L as ToolAnnotations, N as actionVariantConfigSchema, O as actionsConfigSchema, U as agentDefinitionSchema, V as isValidActionName, W as platformAgentConfigSchema } from './types-_lfbhFJH.cjs';
-import * as z from 'zod';
-import { ZodType } from 'zod';
-import 'kraken-ai';
-
-interface ToolResultContent {
-    readonly type: string;
-    [key: string]: unknown;
-}
-interface ToolResult {
-    readonly content: ReadonlyArray<ToolResultContent>;
-    readonly isError?: boolean;
-}
-/** Wrap a handler return value into MCP CallToolResult format */
-declare const wrapToolResult: (value: unknown) => ToolResult;
-/** Wrap a thrown error into MCP CallToolResult format with isError: true */
-declare const wrapToolError: (error: unknown) => ToolResult;
-/** Create an explicit MCP content pass-through result */
-declare const mcpResult: (content: McpContent["content"], isError?: boolean) => McpContent;
+import { ZodType, z } from 'zod';
 
+export declare class SecurityError extends Error {
+	readonly code = "SECURITY_VIOLATION";
+	constructor(message: string);
+}
+export declare class ConnectorError extends Error {
+	readonly code = "CONNECTOR_ERROR";
+	constructor(message: string);
+}
+/**
+ * Joins a repo name and primitive name into the qualified `repo/primitive` form.
+ * Throws if either segment is empty.
+ */
+export declare const qualify: (repoName: string, primitiveName: string) => string;
+/**
+ * Splits a qualified name into its repo and primitive components.
+ * Requires exactly one `/` with non-empty segments on both sides.
+ */
+export declare const parse: (qualified: string) => {
+	repoName: string;
+	primitiveName: string;
+};
+/**
+ * Returns true if the name is in qualified `repo/entity` form —
+ * exactly one `/` with non-empty segments on both sides.
+ * Purely structural; no format validation.
+ */
+export declare const isQualified: (name: string) => boolean;
+/** Action names follow entity naming convention: lowercase alphanumeric with hyphens, 1-64 chars. */
+export declare const ACTION_NAME_REGEX: RegExp;
+/** Validates an action name (allows single-char names like "a"). */
+export declare const isValidActionName: (name: string) => boolean;
+/** Input for a single action in defineAction(). */
+export interface ActionVariantInput<S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> {
+	name: string;
+	schema: S;
+	webhook?: string;
+	handler?(payload: z.infer<S>): Promise<void>;
+}
+/** Serializable config for a single action (stored in manifest/DB). */
+export interface ActionConfig {
+	schema: Record<string, unknown>;
+	webhook?: string;
+	hasHandler: boolean;
+}
+/** Branded action type returned by defineAction(). */
+export interface PlatformAction {
+	readonly __type: "PlatformAction";
+	readonly name: string;
+	readonly config: ActionConfig;
+	readonly zodSchema: z.ZodObject<z.ZodRawShape>;
+	readonly handler?: (payload: unknown) => Promise<void>;
+}
+/** MCP tool annotations per the MCP spec (v1.27.1) */
+export interface ToolAnnotations {
+	readonly readOnlyHint?: boolean;
+	readonly destructiveHint?: boolean;
+	readonly idempotentHint?: boolean;
+	readonly openWorldHint?: boolean;
+}
+/** Explicit MCP content pass-through (returned by mcpResult() helper) */
+export interface McpContent {
+	readonly __mcpPassThrough: true;
+	readonly content: ReadonlyArray<{
+		readonly type: string;
+		[key: string]: unknown;
+	}>;
+	readonly isError?: boolean;
+}
+/**
+ * Union of valid handler return types.
+ * Prevents returning unsupported types at compile time.
+ */
+export type ConnectorHandlerResult = string | number | boolean | Record<string, unknown> | ReadonlyArray<unknown> | McpContent | null | undefined;
+/** Minimal context passed to resource/prompt handlers — business logic only */
+export interface ConnectorHandlerContext {
+	readonly signal: AbortSignal;
+}
+/** MCP-native resource content (text or binary) */
+export type ResourceContent = {
+	readonly uri: string;
+	readonly mimeType?: string;
+	readonly text: string;
+} | {
+	readonly uri: string;
+	readonly mimeType?: string;
+	readonly blob: string;
+};
+/** MCP-native ReadResourceResult — returned by resource read handlers */
+export interface ReadResourceResult {
+	readonly contents: ReadonlyArray<ResourceContent>;
+}
+/** MCP-native prompt message content */
+export type PromptMessageContent = {
+	readonly type: "text";
+	readonly text: string;
+} | {
+	readonly type: "image";
+	readonly data: string;
+	readonly mimeType: string;
+};
+/** MCP-native GetPromptResult — returned by prompt get handlers */
+export interface GetPromptResult {
+	readonly description?: string;
+	readonly messages: ReadonlyArray<{
+		readonly role: "user" | "assistant";
+		readonly content: PromptMessageContent;
+	}>;
+}
+/** A tool definition within a connector */
+export interface ConnectorToolDef<TInput extends ZodType = ZodType> {
+	readonly description: string;
+	readonly input: TInput;
+	readonly annotations?: ToolAnnotations;
+	handler(args: z.infer<TInput>): Promise<ConnectorHandlerResult> | ConnectorHandlerResult;
+}
+/** A resource definition within a connector */
+export interface ConnectorResourceDef {
+	readonly description: string;
+	readonly uri: string;
+	readonly mimeType?: string;
+	read(ctx: ConnectorHandlerContext): Promise<ReadResourceResult> | ReadResourceResult;
+}
+/** A prompt definition within a connector */
+export interface ConnectorPromptDef {
+	readonly description: string;
+	readonly arguments?: ReadonlyArray<{
+		readonly name: string;
+		readonly description?: string;
+		readonly required?: boolean;
+	}>;
+	get(args: Record<string, string>, ctx: ConnectorHandlerContext): Promise<GetPromptResult> | GetPromptResult;
+}
+/** Input to defineConnector() */
+export interface ConnectorDefinition {
+	readonly name: string;
+	readonly description?: string;
+	readonly instructions?: string;
+	readonly tools?: Record<string, ConnectorToolDef>;
+	readonly resources?: Record<string, ConnectorResourceDef>;
+	readonly prompts?: Record<string, ConnectorPromptDef>;
+}
+/** Output of defineConnector() — frozen, carries handlers for server builder */
+export interface PlatformConnector {
+	readonly __type: "PlatformConnector";
+	readonly name: string;
+	readonly description?: string;
+	readonly instructions?: string;
+	readonly tools?: Readonly<Record<string, ConnectorToolDef>>;
+	readonly resources?: Readonly<Record<string, ConnectorResourceDef>>;
+	readonly prompts?: Readonly<Record<string, ConnectorPromptDef>>;
+}
 declare const environmentSchema: z.ZodEnum<{
-    dev: "dev";
-    staging: "staging";
-    prod: "prod";
+	dev: "dev";
+	staging: "staging";
+	prod: "prod";
 }>;
-type Environment = z.infer<typeof environmentSchema>;
-
+export type Environment = z.infer<typeof environmentSchema>;
 declare const jitPolicySchema: z.ZodEnum<{
-    "auto-approve": "auto-approve";
-    "policy-based": "policy-based";
-    "require-approval": "require-approval";
+	"auto-approve": "auto-approve";
+	"policy-based": "policy-based";
+	"require-approval": "require-approval";
 }>;
-type JitPolicy = z.infer<typeof jitPolicySchema>;
+export type JitPolicy = z.infer<typeof jitPolicySchema>;
 declare const identityConfigSchema: z.ZodObject<{
-    basePermissions: z.ZodArray<z.ZodString>;
-    requestablePermissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    jitPolicy: z.ZodOptional<z.ZodEnum<{
-        "auto-approve": "auto-approve";
-        "policy-based": "policy-based";
-        "require-approval": "require-approval";
-    }>>;
-    maxJitDurationMinutes: z.ZodOptional<z.ZodNumber>;
+	basePermissions: z.ZodArray<z.ZodString>;
+	requestablePermissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+	jitPolicy: z.ZodOptional<z.ZodEnum<{
+		"auto-approve": "auto-approve";
+		"policy-based": "policy-based";
+		"require-approval": "require-approval";
+	}>>;
+	maxJitDurationMinutes: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-type IdentityConfig = z.infer<typeof identityConfigSchema>;
-
+export type IdentityConfig = z.infer<typeof identityConfigSchema>;
 declare const notificationConfigSchema: z.ZodObject<{
-    slack: z.ZodOptional<z.ZodString>;
-    onSuccess: z.ZodOptional<z.ZodBoolean>;
-    onFailure: z.ZodOptional<z.ZodBoolean>;
-    onTimeout: z.ZodOptional<z.ZodBoolean>;
+	slack: z.ZodOptional<z.ZodString>;
+	onSuccess: z.ZodOptional<z.ZodBoolean>;
+	onFailure: z.ZodOptional<z.ZodBoolean>;
+	onTimeout: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
-type NotificationConfig = z.infer<typeof notificationConfigSchema>;
-
-interface PlatformSkill {
-    readonly __type: "PlatformSkill";
-    readonly name: string;
-    readonly description?: string;
+export type NotificationConfig = z.infer<typeof notificationConfigSchema>;
+/** Google model ID. */
+export type GoogleModelId = "gemini-3.1-pro-preview" | "gemini-3-flash-preview";
+/** OpenAI model ID. */
+export type OpenAIModelId = "gpt-5.4" | "gpt-4o" | "gpt-4o-mini";
+/** A provider-qualified model string (e.g. `"google/gemini-3.1-pro-preview"`). */
+export type ModelString = `google/${GoogleModelId}` | `openai/${OpenAIModelId}`;
+declare const agentDefinitionSchema: z.ZodObject<{
+	name: z.ZodString;
+	model: z.ZodString;
+	instructions: z.ZodString;
+	description: z.ZodOptional<z.ZodString>;
+	skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+	temperature: z.ZodOptional<z.ZodNumber>;
+	allowTemperatureOverride: z.ZodOptional<z.ZodBoolean>;
+	maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+	thinkingLevel: z.ZodOptional<z.ZodEnum<{
+		low: "low";
+		medium: "medium";
+		high: "high";
+	}>>;
+	logLevel: z.ZodOptional<z.ZodEnum<{
+		error: "error";
+		silent: "silent";
+		debug: "debug";
+		info: "info";
+		warn: "warn";
+	}>>;
+}, z.core.$strict>;
+export type AgentDefinition = Omit<z.infer<typeof agentDefinitionSchema>, "model"> & {
+	model: ModelString;
+};
+declare const platformAgentConfigSchema: z.ZodObject<{
+	agent: z.ZodObject<{
+		name: z.ZodString;
+		model: z.ZodString;
+		instructions: z.ZodString;
+		description: z.ZodOptional<z.ZodString>;
+		skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+		temperature: z.ZodOptional<z.ZodNumber>;
+		allowTemperatureOverride: z.ZodOptional<z.ZodBoolean>;
+		maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+		thinkingLevel: z.ZodOptional<z.ZodEnum<{
+			low: "low";
+			medium: "medium";
+			high: "high";
+		}>>;
+		logLevel: z.ZodOptional<z.ZodEnum<{
+			error: "error";
+			silent: "silent";
+			debug: "debug";
+			info: "info";
+			warn: "warn";
+		}>>;
+	}, z.core.$strict>;
+	connectors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+	triggers: z.ZodArray<z.ZodDiscriminatedUnion<[
+		z.ZodObject<{
+			type: z.ZodLiteral<"cron">;
+			expression: z.ZodString;
+			timezone: z.ZodOptional<z.ZodString>;
+		}, z.core.$strip>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"webhook">;
+			path: z.ZodString;
+			method: z.ZodOptional<z.ZodEnum<{
+				POST: "POST";
+				GET: "GET";
+			}>>;
+		}, z.core.$strip>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"event">;
+			source: z.ZodString;
+			event: z.ZodString;
+		}, z.core.$strip>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"api">;
+		}, z.core.$strip>,
+		z.ZodObject<{
+			type: z.ZodLiteral<"manual">;
+		}, z.core.$strip>
+	], "type">>;
+	identity: z.ZodOptional<z.ZodObject<{
+		basePermissions: z.ZodArray<z.ZodString>;
+		requestablePermissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+		jitPolicy: z.ZodOptional<z.ZodEnum<{
+			"auto-approve": "auto-approve";
+			"policy-based": "policy-based";
+			"require-approval": "require-approval";
+		}>>;
+		maxJitDurationMinutes: z.ZodOptional<z.ZodNumber>;
+	}, z.core.$strip>>;
+	resources: z.ZodOptional<z.ZodObject<{
+		maxTokens: z.ZodOptional<z.ZodNumber>;
+		maxCostUsd: z.ZodOptional<z.ZodNumber>;
+		timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+	}, z.core.$strip>>;
+	retries: z.ZodOptional<z.ZodObject<{
+		maxAttempts: z.ZodOptional<z.ZodNumber>;
+		backoffSeconds: z.ZodOptional<z.ZodNumber>;
+	}, z.core.$strip>>;
+	concurrency: z.ZodOptional<z.ZodObject<{
+		maxParallelRuns: z.ZodOptional<z.ZodNumber>;
+	}, z.core.$strip>>;
+	fast: z.ZodOptional<z.ZodBoolean>;
+	team: z.ZodOptional<z.ZodObject<{
+		members: z.ZodArray<z.ZodString>;
+		maxConcurrentWorkers: z.ZodOptional<z.ZodNumber>;
+		maxTokenBudgetPerWorker: z.ZodOptional<z.ZodNumber>;
+		maxDurationPerWorker: z.ZodOptional<z.ZodNumber>;
+	}, z.core.$strip>>;
+	notifications: z.ZodOptional<z.ZodObject<{
+		slack: z.ZodOptional<z.ZodString>;
+		onSuccess: z.ZodOptional<z.ZodBoolean>;
+		onFailure: z.ZodOptional<z.ZodBoolean>;
+		onTimeout: z.ZodOptional<z.ZodBoolean>;
+	}, z.core.$strip>>;
+	environment: z.ZodOptional<z.ZodEnum<{
+		dev: "dev";
+		staging: "staging";
+		prod: "prod";
+	}>>;
+	actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type PlatformAgentConfig = Omit<z.infer<typeof platformAgentConfigSchema>, "agent"> & {
+	agent: AgentDefinition;
+};
+export interface PlatformAgent {
+	readonly __type: "PlatformAgent";
+	readonly config: PlatformAgentConfig;
+	readonly runtime?: unknown;
+	/** In-memory schemas for action variants. Not serialized — runtime use only. */
+	readonly actionZodSchemas?: Record<string, import("zod").ZodObject<import("zod").ZodRawShape>>;
+	/** Action handler functions. Not serialized — runtime use only. */
+	readonly actionHandlers?: Readonly<Record<string, (payload: unknown) => Promise<void>>>;
+	/** Action webhook URLs. Not serialized — runtime use only. */
+	readonly actionWebhooks?: Readonly<Record<string, string | undefined>>;
+	/** Team member PlatformAgent objects. Not serialized — runtime use only (dev mode delegation). */
+	readonly teamAgents?: readonly PlatformAgent[];
 }
-
-/** Skill reference: local PlatformSkill object or remote SkillId (populated by `kraken generate`). */
-type SkillRef = PlatformSkill | SkillId;
-/** Connector reference: local PlatformConnector, remote ConnectorId, or connector name string. */
-type ConnectorRef = PlatformConnector | ConnectorId | (string & {});
-
 declare const resourceLimitsSchema: z.ZodObject<{
-    maxTokens: z.ZodOptional<z.ZodNumber>;
-    maxCostUsd: z.ZodOptional<z.ZodNumber>;
-    timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+	maxTokens: z.ZodOptional<z.ZodNumber>;
+	maxCostUsd: z.ZodOptional<z.ZodNumber>;
+	timeoutSeconds: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-type ResourceLimits = z.infer<typeof resourceLimitsSchema>;
+export type ResourceLimits = z.infer<typeof resourceLimitsSchema>;
 declare const retryPolicySchema: z.ZodObject<{
-    maxAttempts: z.ZodOptional<z.ZodNumber>;
-    backoffSeconds: z.ZodOptional<z.ZodNumber>;
+	maxAttempts: z.ZodOptional<z.ZodNumber>;
+	backoffSeconds: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-type RetryPolicy = z.infer<typeof retryPolicySchema>;
+export type RetryPolicy = z.infer<typeof retryPolicySchema>;
 declare const concurrencyPolicySchema: z.ZodObject<{
-    maxParallelRuns: z.ZodOptional<z.ZodNumber>;
+	maxParallelRuns: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-type ConcurrencyPolicy = z.infer<typeof concurrencyPolicySchema>;
-
+export type ConcurrencyPolicy = z.infer<typeof concurrencyPolicySchema>;
+export interface PlatformSkill {
+	readonly __type: "PlatformSkill";
+	readonly name: string;
+	readonly description?: string;
+}
 declare const teamConfigSchema: z.ZodObject<{
-    members: z.ZodArray<z.ZodString>;
-    maxConcurrentWorkers: z.ZodOptional<z.ZodNumber>;
-    maxTokenBudgetPerWorker: z.ZodOptional<z.ZodNumber>;
-    maxDurationPerWorker: z.ZodOptional<z.ZodNumber>;
+	members: z.ZodArray<z.ZodString>;
+	maxConcurrentWorkers: z.ZodOptional<z.ZodNumber>;
+	maxTokenBudgetPerWorker: z.ZodOptional<z.ZodNumber>;
+	maxDurationPerWorker: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-type TeamConfig = z.infer<typeof teamConfigSchema>;
-
-declare const triggerConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"cron">;
-    expression: z.ZodString;
-    timezone: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"webhook">;
-    path: z.ZodString;
-    method: z.ZodOptional<z.ZodEnum<{
-        GET: "GET";
-        POST: "POST";
-    }>>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"event">;
-    source: z.ZodString;
-    event: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"api">;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"manual">;
-}, z.core.$strip>], "type">;
-type TriggerConfig = z.infer<typeof triggerConfigSchema>;
-
-type AgentInputField = (Omit<PlatformAgentConfig["agent"], "skills"> & {
-    outputSchema?: ZodType;
-    skills?: SkillRef[];
+export type TeamConfig = z.infer<typeof teamConfigSchema>;
+declare const triggerConfigSchema: z.ZodDiscriminatedUnion<[
+	z.ZodObject<{
+		type: z.ZodLiteral<"cron">;
+		expression: z.ZodString;
+		timezone: z.ZodOptional<z.ZodString>;
+	}, z.core.$strip>,
+	z.ZodObject<{
+		type: z.ZodLiteral<"webhook">;
+		path: z.ZodString;
+		method: z.ZodOptional<z.ZodEnum<{
+			POST: "POST";
+			GET: "GET";
+		}>>;
+	}, z.core.$strip>,
+	z.ZodObject<{
+		type: z.ZodLiteral<"event">;
+		source: z.ZodString;
+		event: z.ZodString;
+	}, z.core.$strip>,
+	z.ZodObject<{
+		type: z.ZodLiteral<"api">;
+	}, z.core.$strip>,
+	z.ZodObject<{
+		type: z.ZodLiteral<"manual">;
+	}, z.core.$strip>
+], "type">;
+export type TriggerConfig = z.infer<typeof triggerConfigSchema>;
+export interface ToolResultContent {
+	readonly type: string;
+	[key: string]: unknown;
+}
+export interface ToolResult {
+	readonly content: ReadonlyArray<ToolResultContent>;
+	readonly isError?: boolean;
+}
+/**
+ * Wrap a tool handler's return value into MCP `CallToolResult` format.
+ *
+ * Automatically converts primitives to `{ type: "text" }` content and
+ * serializes objects to JSON. Pass-through {@link McpContent} values
+ * (created with {@link mcpResult}) are forwarded as-is.
+ *
+ * @param value - The handler's return value (string, number, boolean,
+ *   object, {@link McpContent}, or `null`/`undefined`).
+ * @returns An MCP-compatible tool result.
+ *
+ * @example
+ * ```ts
+ * wrapToolResult("done");          // { content: [{ type: "text", text: "done" }] }
+ * wrapToolResult({ id: 1 });       // { content: [{ type: "text", text: '{\n  "id": 1\n}' }] }
+ * wrapToolResult(null);            // { content: [] }
+ * ```
+ */
+export declare const wrapToolResult: (value: unknown) => ToolResult;
+/**
+ * Wrap a thrown error into MCP `CallToolResult` format with `isError: true`.
+ *
+ * {@link ConnectorError} messages are forwarded to the agent as-is (they
+ * are user-facing). All other errors are replaced with a generic
+ * "Internal handler error" message and logged to stderr.
+ *
+ * @param error - The caught error.
+ * @returns An MCP-compatible error result.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   return wrapToolResult(await handler(args));
+ * } catch (err) {
+ *   return wrapToolError(err);
+ * }
+ * ```
+ */
+export declare const wrapToolError: (error: unknown) => ToolResult;
+/**
+ * Create an explicit MCP content pass-through result.
+ *
+ * Use this when you need full control over the MCP response — for
+ * example, returning an image alongside text or marking a multi-part
+ * response as an error.
+ *
+ * @param content - Array of MCP content blocks (`{ type: "text", text }`,
+ *   `{ type: "image", data, mimeType }`, etc.).
+ * @param isError - If `true`, the result is marked as an error.
+ * @returns An {@link McpContent} object that {@link wrapToolResult}
+ *   forwards without modification.
+ *
+ * @example
+ * ```ts
+ * import { mcpResult } from "@kraken-ai/platform";
+ *
+ * const screenshot = defineTool({
+ *   description: "Take a screenshot",
+ *   input: z.object({ url: z.string().url() }),
+ *   handler: async ({ url }) =>
+ *     mcpResult([
+ *       { type: "text", text: `Screenshot of ${url}` },
+ *       { type: "image", data: base64png, mimeType: "image/png" },
+ *     ]),
+ * });
+ * ```
+ */
+export declare const mcpResult: (content: McpContent["content"], isError?: boolean) => McpContent;
+/**
+ * Type registry populated by `kraken generate` via module augmentation.
+ *
+ * Before generating, all ID types resolve to an error-message string —
+ * only local typed refs (PlatformAgent, PlatformSkill, PlatformConnector) compile.
+ *
+ * After `kraken generate`, the generated `.kraken-ai/platform-types.d.ts` augments
+ * this interface with `agentId`, `connectorId`, and `skillId` string unions,
+ * enabling autocomplete on remote IDs.
+ *
+ * @example
+ * ```ts
+ * // .kraken-ai/platform-types.d.ts (generated)
+ * declare module "@kraken-ai/platform" {
+ *   interface KrakenTypeRegistry {
+ *     agentId: "analyst" | "writer";
+ *     connectorId: "slack" | "jira";
+ *     skillId: "competitor-deep-dive";
+ *   }
+ * }
+ * ```
+ */
+export interface KrakenTypeRegistry {
+}
+/** Remote agent IDs. Resolves to an error hint before `kraken generate`. */
+export type AgentId = KrakenTypeRegistry extends {
+	agentId: infer T extends string;
+} ? T : "ERROR: Run 'kraken generate' to unlock agent IDs";
+/** Remote connector IDs. Resolves to an error hint before `kraken generate`. */
+export type ConnectorId = KrakenTypeRegistry extends {
+	connectorId: infer T extends string;
+} ? T : "ERROR: Run 'kraken generate' to unlock connector IDs";
+/** Remote skill IDs. Resolves to an error hint before `kraken generate`. */
+export type SkillId = KrakenTypeRegistry extends {
+	skillId: infer T extends string;
+} ? T : "ERROR: Run 'kraken generate' to unlock skill IDs";
+/** Remote action IDs. Resolves to an error hint before `kraken generate`. */
+export type ActionId = KrakenTypeRegistry extends {
+	actionId: infer T extends string;
+} ? T : "ERROR: Run 'kraken generate' to unlock action IDs";
+/** Skill reference: local PlatformSkill object or remote SkillId (populated by `kraken generate`). */
+export type SkillRef = PlatformSkill | SkillId;
+/** Connector reference: local PlatformConnector object or remote ConnectorId (populated by `kraken generate`). */
+export type ConnectorRef = PlatformConnector | ConnectorId;
+/** Action reference: local PlatformAction object or remote ActionId (populated by `kraken generate`). */
+export type ActionRef = PlatformAction | ActionId;
+export type TeamMember = PlatformAgent | AgentId;
+export type AgentInputField = (Omit<PlatformAgentConfig["agent"], "skills"> & {
+	outputSchema?: ZodType;
+	skills?: SkillRef[];
 }) | {
-    definition: Record<string, unknown>;
-    name: string;
-    run: (...args: unknown[]) => unknown;
+	definition: Record<string, unknown>;
+	name: string;
+	run: (...args: unknown[]) => unknown;
 };
-interface PlatformAgentInputConfig extends Omit<PlatformAgentConfig, "agent" | "connectors" | "team" | "actions"> {
-    agent: AgentInputField;
-    connectors?: ConnectorRef[];
-    team?: Omit<PlatformAgentConfig["team"] & object, "members"> & {
-        members: TeamMember[];
-    };
-    actions?: PlatformActions;
-}
-declare const definePlatformAgent: <TOutput extends ZodType = ZodType>(config: PlatformAgentInputConfig & {
-    agent: AgentInputField & {
-        outputSchema?: TOutput;
-    };
+export interface PlatformAgentInputConfig extends Omit<PlatformAgentConfig, "agent" | "connectors" | "team" | "actions"> {
+	agent: AgentInputField;
+	connectors?: ConnectorRef[];
+	team?: Omit<PlatformAgentConfig["team"] & object, "members"> & {
+		members: TeamMember[];
+	};
+	actions?: ActionRef[];
+}
+/**
+ * Define a platform agent. Validates at definition time and returns a
+ * frozen {@link PlatformAgent} ready for registration.
+ *
+ * ## Config shape
+ *
+ * ```
+ * {
+ *   agent: {                                    // REQUIRED — the agent itself
+ *     name:          string                     //   REQUIRED — unique agent name
+ *     model:         ModelString                //   REQUIRED — "provider/model-id"
+ *     instructions:  string                     //   REQUIRED — system prompt
+ *     description?:  string                     //   shown to orchestrator agents
+ *     skills?:       SkillRef[]                 //   skill objects or IDs
+ *     temperature?:  number                     //   0–2 (default: model default)
+ *     allowTemperatureOverride?: boolean        //   let callers override temperature
+ *     maxOutputTokens?: number                  //   cap output length
+ *     thinkingLevel?:  "low"|"medium"|"high"    //   reasoning depth
+ *     logLevel?:       "silent"|"debug"|"info"|"warn"|"error"
+ *     outputSchema?:   ZodType                  //   typed structured output
+ *   }
+ *   triggers:       TriggerConfig[]             // REQUIRED — how runs start
+ *     | { type: "manual" }
+ *     | { type: "api" }
+ *     | { type: "cron",    expression: string, timezone?: string }
+ *     | { type: "webhook", path: string,       method?: "POST"|"GET" }
+ *     | { type: "event",   source: string,     event: string }
+ *   connectors?:    ConnectorRef[]              // connector objects or IDs
+ *   actions?:       ActionRef[]                 // action objects or IDs
+ *   team?: {                                    // multi-agent delegation
+ *     members:                TeamMember[]      //   REQUIRED — agent objects or IDs
+ *     maxConcurrentWorkers?:  number            //   parallel worker cap
+ *     maxTokenBudgetPerWorker?: number          //   token limit per worker
+ *     maxDurationPerWorker?:  number            //   seconds per worker
+ *   }
+ *   identity?: {                                // JIT permission escalation
+ *     basePermissions:        string[]          //   REQUIRED — default permissions
+ *     requestablePermissions?: string[]         //   permissions the agent can request
+ *     jitPolicy?:  "auto-approve"|"policy-based"|"require-approval"
+ *     maxJitDurationMinutes?: number
+ *   }
+ *   resources?: {                               // cost & runtime guardrails
+ *     maxTokens?:        number
+ *     maxCostUsd?:       number
+ *     timeoutSeconds?:   number
+ *   }
+ *   retries?: {                                 // automatic retry on failure
+ *     maxAttempts?:     number
+ *     backoffSeconds?:  number
+ *   }
+ *   concurrency?: {                             // run-level concurrency
+ *     maxParallelRuns?: number
+ *   }
+ *   notifications?: {                           // Slack alerts
+ *     slack?:      string                       //   channel or webhook URL
+ *     onSuccess?:  boolean
+ *     onFailure?:  boolean
+ *     onTimeout?:  boolean
+ *   }
+ *   fast?:          boolean                     // pre-provision connectors for low latency
+ *   environment?:   "dev"|"staging"|"prod"
+ * }
+ * ```
+ *
+ * @returns A frozen {@link PlatformAgent} object.
+ * @throws {SecurityError} If `agent` contains forbidden keys (`tools`,
+ *   `team`, `kernel`) — those are platform-managed.
+ *
+ * @example
+ * ```ts
+ * export default definePlatformAgent({
+ *   agent: {
+ *     name: "market-intel",
+ *     model: "openai/gpt-4o",
+ *     instructions: "You are a market research analyst.",
+ *     temperature: 0.3,
+ *   },
+ *   triggers: [{ type: "manual" }],
+ *   connectors: [jiraConnector, slackConnector],
+ *   resources: { maxTokens: 100_000, maxCostUsd: 5 },
+ * });
+ * ```
+ */
+export declare const definePlatformAgent: <TOutput extends ZodType = ZodType>(config: PlatformAgentInputConfig & {
+	agent: AgentInputField & {
+		outputSchema?: TOutput;
+	};
 }) => PlatformAgent & {
-    outputSchema?: TOutput;
+	outputSchema?: TOutput;
 };
-
 /**
- * Define an action variant.
+ * Define a standalone action with a name, Zod schema, optional webhook, and
+ * optional handler.
  *
- * Infers handler payload types from the schema.
+ * Actions are the agent's typed terminal outputs — each action is a possible
+ * decision the agent can make. The handler's payload type is inferred from
+ * the schema, giving you end-to-end type safety.
+ *
+ * @param input - Action name, schema, optional webhook URL, and optional handler.
+ * @returns A frozen {@link PlatformAction} object.
+ * @throws If `name` is empty, invalid, or longer than 64 chars.
  *
  * @example
  * ```ts
- * defineAction({
- *   schema: z.object({ reason: z.string() }),
+ * import { defineAction } from "@kraken-ai/platform";
+ * import { z } from "zod";
+ *
+ * export default defineAction({
+ *   name: "approve",
+ *   schema: z.object({ reason: z.string(), confidence: z.number() }),
  *   handler: async (payload) => {
- *     payload.reason; // string — fully typed
+ *     payload.reason;     // string
+ *     payload.confidence; // number
  *   },
  * });
  * ```
  */
-declare const defineAction: <S extends z.ZodObject<z.ZodRawShape>>(input: ActionVariantInput<S>) => ActionVariantInput<S>;
+export declare const defineAction: <S extends z.ZodObject<z.ZodRawShape>>(input: ActionVariantInput<S>) => PlatformAction;
 /**
- * Define action variants for a platform agent. Actions are typed terminal
- * outputs — the agent's final decision as structured output.
+ * Build a discriminated-union Zod schema from action definitions.
  *
- * Each variant has a name and an object schema. Schemas are serialized
- * to JSON Schema for discovery/storage, and the originals are preserved
- * in-memory for runtime validation.
+ * Each action becomes `z.object({ action: z.literal(name), ...fields })`,
+ * and the union discriminates on the `action` key. Pass the result as
+ * `outputSchema` in {@link definePlatformAgent} to constrain the agent's
+ * structured output to exactly one of the defined actions.
  *
- * Handler payload types are inferred from the schema automatically:
+ * @param actions - Array of {@link PlatformAction} objects returned by {@link defineAction}.
+ * @returns A `z.ZodDiscriminatedUnion` schema.
+ * @throws If `actions` is empty.
  *
  * @example
  * ```ts
- * const actions = defineActions({
- *   approve: {
- *     schema: z.object({ reason: z.string() }),
- *     handler: async (payload) => {
- *       payload.reason; // string — fully typed
- *     },
- *   },
- *   reject: { schema: z.object({ reason: z.string(), severity: z.number() }) },
+ * import { defineAction, buildActionOutputSchema } from "@kraken-ai/platform";
+ * import { z } from "zod";
+ *
+ * const approve = defineAction({
+ *   name: "approve",
+ *   schema: z.object({ reason: z.string() }),
+ * });
+ * const reject = defineAction({
+ *   name: "reject",
+ *   schema: z.object({ reason: z.string() }),
  * });
+ *
+ * const outputSchema = buildActionOutputSchema([approve, reject]);
+ * // Accepts: { action: "approve", reason: "..." }
+ * //      or: { action: "reject",  reason: "..." }
  * ```
  */
-declare const defineActions: <V extends Record<string, ActionVariantInput>>(variants: V) => PlatformActions;
+export declare const buildActionOutputSchema: (actions: PlatformAction[]) => z.ZodDiscriminatedUnion<[
+	z.ZodObject<{
+		readonly [x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+	}, z.core.$strip>,
+	...z.ZodObject<{
+		readonly [x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+	}, z.core.$strip>[]
+], "action">;
 /**
- * Build a discriminated-union schema from action definitions.
- * Each variant becomes `z.object({ action: z.literal(name), ...variantSchema })`.
- * Used as the agent's outputSchema to constrain LLM structured output.
+ * Define a single tool for use inside a connector.
+ *
+ * Accepts a Zod schema as `input` and infers the handler's argument types
+ * from it, giving you end-to-end type safety from schema to handler.
+ *
+ * @example
+ * ```ts
+ * const add = defineTool({
+ *   description: "Add two numbers",
+ *   input: z.object({ a: z.number(), b: z.number() }),
+ *   handler: ({ a, b }) => a + b,
+ * });
+ * ```
  */
-declare const buildActionOutputSchema: (actions: PlatformActions) => z.ZodDiscriminatedUnion<[z.ZodObject<{
-    readonly [x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-}, z.core.$strip>, ...z.ZodObject<{
-    readonly [x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-}, z.core.$strip>[]], "action">;
-
+export declare const defineTool: <T extends ZodType>(def: ConnectorToolDef<T>) => ConnectorToolDef<T>;
 /**
- * Define a connector tool.
+ * Define a connector that exposes tools, resources, and prompts to AI agents
+ * through the Kraken platform.
+ *
+ * A connector is the primary building block for extending agent capabilities.
+ * Each connector is served as an MCP server and can provide:
+ *
+ * - **Tools** — functions the agent can call (defined with {@link defineTool})
+ * - **Resources** — data the agent can read (files, database rows, API responses)
+ * - **Prompts** — reusable prompt templates the agent can invoke
+ *
+ * The returned object is deeply frozen and ready to be passed to the platform
+ * server builder.
+ *
+ * @param input - The connector definition including a unique name and optional
+ *   tools, resources, and prompts.
+ * @returns A frozen {@link PlatformConnector} object.
+ * @throws If `name` is empty.
+ *
+ * @example
+ * ```ts
+ * import { defineConnector, defineTool } from "@kraken-ai/platform";
+ * import { z } from "zod";
  *
- * Infers handler arg types from the `input` schema.
+ * export default defineConnector({
+ *   name: "math",
+ *   description: "Basic math operations",
+ *   tools: {
+ *     add: defineTool({
+ *       description: "Add two numbers",
+ *       input: z.object({ a: z.number(), b: z.number() }),
+ *       handler: ({ a, b }) => a + b,
+ *     }),
+ *   },
+ * });
+ * ```
  */
-declare const defineTool: <T extends z.ZodType>(def: ConnectorToolDef<T>) => ConnectorToolDef<T>;
-declare const defineConnector: <const T extends ConnectorDefinition>(input: T) => PlatformConnector;
-
-declare const defineSkill: (input: {
-    name: string;
-    description?: string;
+export declare const defineConnector: <const T extends ConnectorDefinition>(input: T) => PlatformConnector;
+/**
+ * Define a reusable skill that can be attached to one or more agents.
+ *
+ * A skill is a named capability (e.g. "competitor-deep-dive") that the
+ * platform resolves into the appropriate prompt and tool set at runtime.
+ * Skills are referenced by agents via the `skills` array in
+ * {@link definePlatformAgent}.
+ *
+ * @param input - Skill name and optional description.
+ * @returns A frozen {@link PlatformSkill} object.
+ * @throws If `name` is empty.
+ *
+ * @example
+ * ```ts
+ * import { defineSkill, definePlatformAgent } from "@kraken-ai/platform";
+ *
+ * const deepDive = defineSkill({
+ *   name: "competitor-deep-dive",
+ *   description: "In-depth competitor analysis with market sizing",
+ * });
+ *
+ * export default definePlatformAgent({
+ *   agent: {
+ *     name: "analyst",
+ *     model: "anthropic/claude-sonnet-4-20250514",
+ *     instructions: "You are a competitive analyst.",
+ *     skills: [deepDive],
+ *   },
+ *   triggers: [{ type: "manual" }],
+ * });
+ * ```
+ */
+export declare const defineSkill: (input: {
+	name: string;
+	description?: string;
 }) => PlatformSkill;
-
-declare class SecurityError extends Error {
-    readonly code = "SECURITY_VIOLATION";
-    constructor(message: string);
-}
-declare class ConnectorError extends Error {
-    readonly code = "CONNECTOR_ERROR";
-    constructor(message: string);
-}
-
-declare const MANIFEST_START = "---KRAKEN-MANIFEST-START---";
-declare const MANIFEST_END = "---KRAKEN-MANIFEST-END---";
+export declare const MANIFEST_START = "---KRAKEN-MANIFEST-START---";
+export declare const MANIFEST_END = "---KRAKEN-MANIFEST-END---";
 declare const projectManifestSchema: z.ZodObject<{
-    agents: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        entryPoint: z.ZodString;
-        config: z.ZodObject<{
-            agent: z.ZodObject<{
-                name: z.ZodString;
-                model: z.ZodString;
-                instructions: z.ZodString;
-                description: z.ZodOptional<z.ZodString>;
-                skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                temperature: z.ZodOptional<z.ZodNumber>;
-                allowTemperatureOverride: z.ZodOptional<z.ZodBoolean>;
-                maxOutputTokens: z.ZodOptional<z.ZodNumber>;
-                thinkingLevel: z.ZodOptional<z.ZodEnum<{
-                    low: "low";
-                    medium: "medium";
-                    high: "high";
-                }>>;
-                logLevel: z.ZodOptional<z.ZodEnum<{
-                    error: "error";
-                    silent: "silent";
-                    debug: "debug";
-                    info: "info";
-                    warn: "warn";
-                }>>;
-            }, z.core.$strict>;
-            connectors: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            triggers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                type: z.ZodLiteral<"cron">;
-                expression: z.ZodString;
-                timezone: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>, z.ZodObject<{
-                type: z.ZodLiteral<"webhook">;
-                path: z.ZodString;
-                method: z.ZodOptional<z.ZodEnum<{
-                    GET: "GET";
-                    POST: "POST";
-                }>>;
-            }, z.core.$strip>, z.ZodObject<{
-                type: z.ZodLiteral<"event">;
-                source: z.ZodString;
-                event: z.ZodString;
-            }, z.core.$strip>, z.ZodObject<{
-                type: z.ZodLiteral<"api">;
-            }, z.core.$strip>, z.ZodObject<{
-                type: z.ZodLiteral<"manual">;
-            }, z.core.$strip>], "type">>;
-            identity: z.ZodOptional<z.ZodObject<{
-                basePermissions: z.ZodArray<z.ZodString>;
-                requestablePermissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                jitPolicy: z.ZodOptional<z.ZodEnum<{
-                    "auto-approve": "auto-approve";
-                    "policy-based": "policy-based";
-                    "require-approval": "require-approval";
-                }>>;
-                maxJitDurationMinutes: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-            resources: z.ZodOptional<z.ZodObject<{
-                maxTokens: z.ZodOptional<z.ZodNumber>;
-                maxCostUsd: z.ZodOptional<z.ZodNumber>;
-                timeoutSeconds: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-            retries: z.ZodOptional<z.ZodObject<{
-                maxAttempts: z.ZodOptional<z.ZodNumber>;
-                backoffSeconds: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-            concurrency: z.ZodOptional<z.ZodObject<{
-                maxParallelRuns: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-            team: z.ZodOptional<z.ZodObject<{
-                members: z.ZodArray<z.ZodString>;
-                maxConcurrentWorkers: z.ZodOptional<z.ZodNumber>;
-                maxTokenBudgetPerWorker: z.ZodOptional<z.ZodNumber>;
-                maxDurationPerWorker: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-            notifications: z.ZodOptional<z.ZodObject<{
-                slack: z.ZodOptional<z.ZodString>;
-                onSuccess: z.ZodOptional<z.ZodBoolean>;
-                onFailure: z.ZodOptional<z.ZodBoolean>;
-                onTimeout: z.ZodOptional<z.ZodBoolean>;
-            }, z.core.$strip>>;
-            environment: z.ZodOptional<z.ZodEnum<{
-                dev: "dev";
-                staging: "staging";
-                prod: "prod";
-            }>>;
-            actions: z.ZodOptional<z.ZodObject<{
-                variants: z.ZodRecord<z.ZodString, z.ZodObject<{
-                    schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-                    webhook: z.ZodOptional<z.ZodString>;
-                    hasHandler: z.ZodBoolean;
-                }, z.core.$strip>>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>;
-    }, z.core.$strip>>;
-    skills: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        path: z.ZodString;
-        content: z.ZodString;
-    }, z.core.$strip>>;
-    connectors: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        path: z.ZodString;
-    }, z.core.$strip>>;
+	agents: z.ZodArray<z.ZodObject<{
+		name: z.ZodString;
+		entryPoint: z.ZodString;
+		config: z.ZodObject<{
+			agent: z.ZodObject<{
+				name: z.ZodString;
+				model: z.ZodString;
+				instructions: z.ZodString;
+				description: z.ZodOptional<z.ZodString>;
+				skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+				temperature: z.ZodOptional<z.ZodNumber>;
+				allowTemperatureOverride: z.ZodOptional<z.ZodBoolean>;
+				maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+				thinkingLevel: z.ZodOptional<z.ZodEnum<{
+					low: "low";
+					medium: "medium";
+					high: "high";
+				}>>;
+				logLevel: z.ZodOptional<z.ZodEnum<{
+					error: "error";
+					silent: "silent";
+					debug: "debug";
+					info: "info";
+					warn: "warn";
+				}>>;
+			}, z.core.$strict>;
+			connectors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+			triggers: z.ZodArray<z.ZodDiscriminatedUnion<[
+				z.ZodObject<{
+					type: z.ZodLiteral<"cron">;
+					expression: z.ZodString;
+					timezone: z.ZodOptional<z.ZodString>;
+				}, z.core.$strip>,
+				z.ZodObject<{
+					type: z.ZodLiteral<"webhook">;
+					path: z.ZodString;
+					method: z.ZodOptional<z.ZodEnum<{
+						POST: "POST";
+						GET: "GET";
+					}>>;
+				}, z.core.$strip>,
+				z.ZodObject<{
+					type: z.ZodLiteral<"event">;
+					source: z.ZodString;
+					event: z.ZodString;
+				}, z.core.$strip>,
+				z.ZodObject<{
+					type: z.ZodLiteral<"api">;
+				}, z.core.$strip>,
+				z.ZodObject<{
+					type: z.ZodLiteral<"manual">;
+				}, z.core.$strip>
+			], "type">>;
+			identity: z.ZodOptional<z.ZodObject<{
+				basePermissions: z.ZodArray<z.ZodString>;
+				requestablePermissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+				jitPolicy: z.ZodOptional<z.ZodEnum<{
+					"auto-approve": "auto-approve";
+					"policy-based": "policy-based";
+					"require-approval": "require-approval";
+				}>>;
+				maxJitDurationMinutes: z.ZodOptional<z.ZodNumber>;
+			}, z.core.$strip>>;
+			resources: z.ZodOptional<z.ZodObject<{
+				maxTokens: z.ZodOptional<z.ZodNumber>;
+				maxCostUsd: z.ZodOptional<z.ZodNumber>;
+				timeoutSeconds: z.ZodOptional<z.ZodNumber>;
+			}, z.core.$strip>>;
+			retries: z.ZodOptional<z.ZodObject<{
+				maxAttempts: z.ZodOptional<z.ZodNumber>;
+				backoffSeconds: z.ZodOptional<z.ZodNumber>;
+			}, z.core.$strip>>;
+			concurrency: z.ZodOptional<z.ZodObject<{
+				maxParallelRuns: z.ZodOptional<z.ZodNumber>;
+			}, z.core.$strip>>;
+			fast: z.ZodOptional<z.ZodBoolean>;
+			team: z.ZodOptional<z.ZodObject<{
+				members: z.ZodArray<z.ZodString>;
+				maxConcurrentWorkers: z.ZodOptional<z.ZodNumber>;
+				maxTokenBudgetPerWorker: z.ZodOptional<z.ZodNumber>;
+				maxDurationPerWorker: z.ZodOptional<z.ZodNumber>;
+			}, z.core.$strip>>;
+			notifications: z.ZodOptional<z.ZodObject<{
+				slack: z.ZodOptional<z.ZodString>;
+				onSuccess: z.ZodOptional<z.ZodBoolean>;
+				onFailure: z.ZodOptional<z.ZodBoolean>;
+				onTimeout: z.ZodOptional<z.ZodBoolean>;
+			}, z.core.$strip>>;
+			environment: z.ZodOptional<z.ZodEnum<{
+				dev: "dev";
+				staging: "staging";
+				prod: "prod";
+			}>>;
+			actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+		}, z.core.$strict>;
+	}, z.core.$strip>>;
+	skills: z.ZodArray<z.ZodObject<{
+		name: z.ZodString;
+		path: z.ZodString;
+		content: z.ZodString;
+	}, z.core.$strip>>;
+	connectors: z.ZodArray<z.ZodObject<{
+		name: z.ZodString;
+		path: z.ZodString;
+		toolSpecs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+			name: z.ZodString;
+			description: z.ZodString;
+			parameters: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+			annotations: z.ZodOptional<z.ZodObject<{
+				readOnlyHint: z.ZodOptional<z.ZodBoolean>;
+				destructiveHint: z.ZodOptional<z.ZodBoolean>;
+				idempotentHint: z.ZodOptional<z.ZodBoolean>;
+			}, z.core.$strip>>;
+		}, z.core.$strip>>>;
+		resourceSpecs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+			name: z.ZodString;
+			uri: z.ZodString;
+			description: z.ZodString;
+			mimeType: z.ZodOptional<z.ZodString>;
+		}, z.core.$strip>>>;
+		promptSpecs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+			name: z.ZodString;
+			description: z.ZodString;
+			arguments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+				name: z.ZodString;
+				description: z.ZodOptional<z.ZodString>;
+				required: z.ZodOptional<z.ZodBoolean>;
+			}, z.core.$strip>>>;
+		}, z.core.$strip>>>;
+	}, z.core.$strip>>;
+	actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+		name: z.ZodString;
+		entryPoint: z.ZodString;
+		config: z.ZodObject<{
+			schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+			webhook: z.ZodOptional<z.ZodString>;
+			hasHandler: z.ZodBoolean;
+		}, z.core.$strip>;
+	}, z.core.$strip>>>;
 }, z.core.$strip>;
-type ProjectManifest = z.infer<typeof projectManifestSchema>;
+export type ProjectManifest = z.infer<typeof projectManifestSchema>;
 /** Parse manifest from stdout that may contain noise before/after sentinel markers. */
-declare const parseManifestFromOutput: (stdout: string) => ProjectManifest;
-
-declare class PlatformError extends Error {
-    readonly status: number;
-    constructor(message: string, status: number);
+export declare const parseManifestFromOutput: (stdout: string) => ProjectManifest;
+export declare class PlatformError extends Error {
+	readonly status: number;
+	constructor(message: string, status: number);
 }
 declare class HttpClient {
-    readonly baseUrlForStream: string;
-    private readonly baseUrl;
-    private readonly apiKey;
-    constructor(config: PlatformClientConfig);
-    get<T>(path: string, params?: Record<string, string>): Promise<T>;
-    post<T>(path: string, body?: unknown): Promise<T>;
-    postStream(path: string, body: unknown, signal?: AbortSignal): Promise<Response>;
-    private buildUrl;
-    authHeaders(): Record<string, string>;
-    private handleResponse;
+	readonly baseUrlForStream: string;
+	private readonly baseUrl;
+	private readonly apiKey;
+	constructor(config: {
+		baseUrl: string;
+		apiKey: string;
+	});
+	get<T>(path: string, params?: Record<string, string>): Promise<T>;
+	post<T>(path: string, body?: unknown): Promise<T>;
+	postStream(path: string, body: unknown, signal?: AbortSignal): Promise<Response>;
+	private buildUrl;
+	authHeaders(): Record<string, string>;
+	private handleResponse;
 }
-
-interface AgentRegistryEntry {
-    input: unknown;
-    output: unknown;
-    actions: Record<string, unknown>;
+export interface PlatformClientConfig {
+	baseUrl?: string;
+	apiKey?: string;
+}
+export interface PaginationParams {
+	cursor?: string;
+	limit?: number;
+}
+export interface PaginatedResponse<T> {
+	data: T[];
+	cursor: string | null;
+	hasMore: boolean;
+}
+export type AgentEvent = {
+	type: "text";
+	content: string;
+} | {
+	type: "tool_call";
+	name: string;
+	args: Record<string, unknown>;
+} | {
+	type: "tool_result";
+	name: string;
+	result: unknown;
+} | {
+	type: "thinking";
+	content: string;
+} | {
+	type: "action";
+	name: string;
+	payload: Record<string, unknown>;
+	actionExecutionId: string;
+} | {
+	type: "done";
+	output: string;
+	usage?: {
+		tokens: number;
+	};
+} | {
+	type: "error";
+	message: string;
+	code: string;
+};
+export interface AgentInfo {
+	id: string;
+	name: string;
+	description?: string;
+}
+export interface ThreadInfo {
+	id: string;
+	agentId: string;
+	createdAt: string;
+	updatedAt: string;
+}
+export interface ThreadMessage {
+	id: string;
+	threadId: string;
+	role: "user" | "assistant";
+	content: string;
+	toolCalls?: Array<{
+		name: string;
+		args: Record<string, unknown>;
+		result: unknown;
+	}>;
+	createdAt: string;
+	usage?: {
+		tokens: number;
+	};
+}
+export interface QueryInfo {
+	name: string;
+	description?: string;
+	params: Record<string, unknown>;
+	columns: QueryColumn[];
+}
+export interface QueryColumn {
+	name: string;
+	type: string;
+	description?: string;
+}
+export interface QueryResult<TRow = Record<string, unknown>> {
+	rows: TRow[];
+	cursor: string | null;
+	hasMore: boolean;
+}
+export type RunState = "QUEUED" | "PROVISIONING" | "RUNNING" | "DRAINING" | "COMPLETED" | "FAILED" | "AWAITING_APPROVAL" | "RETRYING";
+export interface RunRecord {
+	runId: string;
+	agentId: string;
+	input: string;
+	state: RunState;
+	exitCode?: number;
+	createdAt: string;
+	updatedAt: string;
+	retryCount: number;
+	error?: string;
+}
+export interface StartRunParams {
+	agentId: string;
+	tag?: string;
+	environment?: "dev" | "staging" | "prod";
+	input: string;
+	connectors?: string[];
+	envVars?: Record<string, string>;
+	/** When true, tool calls are logged but not executed. */
+	dryRun?: boolean;
+}
+export interface RunEvent {
+	eventId: string;
+	eventType: string;
+	payload: Record<string, unknown>;
+}
+export interface AgentSchema {
+	id: string;
+	name: string;
+	input: Record<string, unknown>;
+	output: Record<string, unknown>;
+	actions?: Record<string, Record<string, unknown>>;
+	config?: {
+		actions?: string[];
+		[key: string]: unknown;
+	};
+}
+export interface QuerySchema {
+	name: string;
+	params: Record<string, unknown>;
+	columns: QueryColumn[];
+}
+export interface ConnectorSchema {
+	id: string;
+	tools: Array<{
+		name: string;
+		description: string;
+		parameters: Record<string, unknown>;
+	}>;
+}
+export interface SkillSchema {
+	id: string;
+	name: string;
+	description?: string;
+}
+export interface ActionSchema {
+	id: string;
+	name: string;
+	schema: Record<string, unknown>;
+	hasHandler: boolean;
+}
+export interface AgentRegistryEntry {
+	input: unknown;
+	output: unknown;
+	actions: Record<string, unknown>;
 }
 /**
  * Augmentable agent registry — `kraken generate` populates this via
  * `declare module "@kraken-ai/platform" { interface AgentRegistry { ... } }`.
  * When populated, `client.agent("id")` infers input/output/actions automatically.
  */
-type AgentRegistry = {};
-interface GenerateOpts {
-    signal?: AbortSignal;
-}
-interface GenerateResult<T extends AgentRegistryEntry> {
-    readonly threadId: string;
-    stream(): AsyncIterable<AgentEvent>;
-    readonly result: Promise<T["output"]>;
-}
-declare class AgentHandle<T extends AgentRegistryEntry> {
-    private readonly http;
-    private readonly agentId;
-    private readonly actionHandlers;
-    private threadId;
-    constructor(http: HttpClient, agentId: string, opts?: {
-        threadId?: string;
-    });
-    onAction<K extends keyof T["actions"] & string>(name: K, handler: (payload: T["actions"][K]) => void | Promise<void>): void;
-    generate(input: T["input"], opts?: GenerateOpts): Promise<GenerateResult<T>>;
+export interface AgentRegistry {
 }
-
-declare class AgentThread {
-    private readonly http;
-    private readonly agentId;
-    readonly threadId: string;
-    constructor(http: HttpClient, agentId: string, threadId: string);
-    sendMessage(content: string, opts?: {
-        signal?: AbortSignal;
-    }): Promise<AsyncIterable<AgentEvent>>;
-    getMessages(params?: PaginationParams): Promise<PaginatedResponse<ThreadMessage>>;
+export interface GenerateOpts {
+	signal?: AbortSignal;
+}
+export interface GenerateResult<T extends AgentRegistryEntry> {
+	readonly threadId: string;
+	stream(): AsyncIterable<AgentEvent>;
+	readonly result: Promise<T["output"]>;
+}
+export declare class AgentHandle<T extends AgentRegistryEntry> {
+	private readonly http;
+	private readonly agentId;
+	private readonly actionHandlers;
+	private threadId;
+	constructor(http: HttpClient, agentId: string, opts?: {
+		threadId?: string;
+	});
+	onAction<K extends keyof T["actions"] & string>(name: K, handler: (payload: T["actions"][K]) => void | Promise<void>): void;
+	generate(input: T["input"], opts?: GenerateOpts): Promise<GenerateResult<T>>;
+}
+export declare class AgentThread {
+	private readonly http;
+	private readonly agentId;
+	readonly threadId: string;
+	constructor(http: HttpClient, agentId: string, threadId: string);
+	sendMessage(content: string, opts?: {
+		signal?: AbortSignal;
+	}): Promise<AsyncIterable<AgentEvent>>;
+	getMessages(params?: PaginationParams): Promise<PaginatedResponse<ThreadMessage>>;
 }
 declare class AgentsNamespace {
-    private readonly http;
-    constructor(http: HttpClient);
-    list(): Promise<AgentInfo[]>;
-    createThread(agentId: string): Promise<AgentThread>;
-    getThread(agentId: string, threadId: string): Promise<AgentThread>;
-    listThreads(agentId: string, params?: PaginationParams): Promise<PaginatedResponse<ThreadInfo>>;
+	private readonly http;
+	constructor(http: HttpClient);
+	list(): Promise<AgentInfo[]>;
+	createThread(agentId: string): Promise<AgentThread>;
+	getThread(agentId: string, threadId: string): Promise<AgentThread>;
+	listThreads(agentId: string, params?: PaginationParams): Promise<PaginatedResponse<ThreadInfo>>;
 }
-
 declare class DataNamespace {
-    private readonly http;
-    constructor(http: HttpClient);
-    list(): Promise<QueryInfo[]>;
-    describe(queryName: string): Promise<QueryInfo>;
-    query<TRow = Record<string, unknown>>(queryName: string, params?: Record<string, unknown>, pagination?: PaginationParams): Promise<QueryResult<TRow>>;
+	private readonly http;
+	constructor(http: HttpClient);
+	list(): Promise<QueryInfo[]>;
+	describe(queryName: string): Promise<QueryInfo>;
+	query<TRow = Record<string, unknown>>(queryName: string, params?: Record<string, unknown>, pagination?: PaginationParams): Promise<QueryResult<TRow>>;
 }
-
-interface QuerySchema<P extends z.ZodType, R extends z.ZodType> {
-    params: P;
-    returns: R;
+export interface PipelineQueryDef<P extends ZodType, R extends ZodType> {
+	params: P;
+	returns: R;
 }
 declare class PipelinesNamespace {
-    private readonly http;
-    constructor(http: HttpClient);
-    query<P extends z.ZodType, R extends z.ZodType>(pipeline: string, queryName: string, schema: QuerySchema<P, R>, params: z.infer<P>): Promise<z.infer<R>[]>;
+	private readonly http;
+	constructor(http: HttpClient);
+	query<P extends ZodType, R extends ZodType>(pipeline: string, queryName: string, schema: PipelineQueryDef<P, R>, params: z.infer<P>): Promise<z.infer<R>[]>;
 }
-
 declare class RunsNamespace {
-    private readonly http;
-    constructor(http: HttpClient);
-    start(params: StartRunParams): Promise<{
-        runId: string;
-    }>;
-    get(runId: string): Promise<RunRecord>;
-    cancel(runId: string): Promise<{
-        success: boolean;
-    }>;
-    getEvents(runId: string, opts?: {
-        afterEventId?: string;
-    }): Promise<{
-        events: RunEvent[];
-    }>;
-    streamEvents(runId: string, opts?: {
-        signal?: AbortSignal;
-    }): AsyncGenerator<RunEvent>;
+	private readonly http;
+	constructor(http: HttpClient);
+	start(params: StartRunParams): Promise<{
+		runId: string;
+	}>;
+	get(runId: string): Promise<RunRecord>;
+	cancel(runId: string): Promise<{
+		success: boolean;
+	}>;
+	getEvents(runId: string, opts?: {
+		afterEventId?: string;
+	}): Promise<{
+		events: RunEvent[];
+	}>;
+	streamEvents(runId: string, opts?: {
+		signal?: AbortSignal;
+	}): AsyncGenerator<RunEvent>;
 }
-
+/** When AgentRegistry is populated (after `kraken generate`), constrain to known keys for autocomplete. Otherwise accept any string. */
+export type AgentIdConstraint = keyof AgentRegistry extends never ? string : keyof AgentRegistry;
 /** Resolve agent type: if K is a known key in AgentRegistry use it, otherwise fall back to AgentRegistryEntry. */
-type ResolveAgent<K extends string> = K extends keyof AgentRegistry ? AgentRegistry[K] : AgentRegistryEntry;
-declare class PlatformClient {
-    readonly agents: AgentsNamespace;
-    readonly data: DataNamespace;
-    readonly pipelines: PipelinesNamespace;
-    readonly runs: RunsNamespace;
-    private readonly http;
-    constructor(config: PlatformClientConfig);
-    agent<K extends string>(id: K, opts?: {
-        mode?: "local" | "remote";
-        threadId?: string;
-    }): AgentHandle<ResolveAgent<K>>;
+export type ResolveAgent<K extends string> = K extends keyof AgentRegistry ? AgentRegistry[K] : AgentRegistryEntry;
+export declare class PlatformClient {
+	readonly agents: AgentsNamespace;
+	readonly data: DataNamespace;
+	readonly pipelines: PipelinesNamespace;
+	readonly runs: RunsNamespace;
+	private readonly http;
+	constructor(config?: PlatformClientConfig);
+	agent<K extends AgentIdConstraint>(id: K, opts?: {
+		mode?: "local" | "remote";
+		threadId?: string;
+	}): AgentHandle<ResolveAgent<K>>;
 }
 
-export { ActionVariantInput, AgentEvent, AgentHandle, AgentInfo, type AgentRegistry, type AgentRegistryEntry, AgentThread, type ConcurrencyPolicy, ConnectorDefinition, ConnectorError, ConnectorId, type ConnectorRef, ConnectorToolDef, type Environment, type GenerateOpts, type GenerateResult, type IdentityConfig, type JitPolicy, MANIFEST_END, MANIFEST_START, McpContent, type NotificationConfig, PaginatedResponse, PaginationParams, PlatformActions, PlatformAgent, PlatformAgentConfig, PlatformClient, PlatformClientConfig, PlatformConnector, PlatformError, type PlatformSkill, type ProjectManifest, QueryInfo, QueryResult, type ResourceLimits, type RetryPolicy, RunEvent, RunRecord, SecurityError, SkillId, type SkillRef, StartRunParams, type TeamConfig, TeamMember, ThreadInfo, ThreadMessage, type TriggerConfig, buildActionOutputSchema, concurrencyPolicySchema, defineAction, defineActions, defineConnector, definePlatformAgent, defineSkill, defineTool, environmentSchema, identityConfigSchema, jitPolicySchema, mcpResult, notificationConfigSchema, parseManifestFromOutput, projectManifestSchema, resourceLimitsSchema, retryPolicySchema, teamConfigSchema, triggerConfigSchema, wrapToolError, wrapToolResult };
+export {
+	z,
+};
+
+export {};