@kraken-ai/platform 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,796 @@
+import { M as McpContent, P as PlatformConnector, C as ConnectorDefinition, a as ConnectorToolDef } from './connector-CumEDPfS.cjs';
+export { b as ConnectorHandlerContext, c as ConnectorHandlerResult, d as ConnectorPromptDef, e as ConnectorResourceDef, G as GetPromptResult, f as PromptMessageContent, R as ReadResourceResult, g as ResourceContent, T as ToolAnnotations } from './connector-CumEDPfS.cjs';
+import * as z from 'zod';
+import { ZodType } from 'zod';
+import { ModelString, ToolDefinition } from '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;
+
+/** Action names follow entity naming convention: lowercase alphanumeric with hyphens, 1-64 chars. */
+declare const ACTION_NAME_REGEX: RegExp;
+/** Validates an action name (allows single-char names like "a"). */
+declare const isValidActionName: (name: string) => boolean;
+/** Input for a single action variant in defineActions(). */
+interface ActionVariantInput<S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> {
+    schema: S;
+    webhook?: string;
+    handler?(payload: z.infer<S>): Promise<void>;
+}
+/** Serializable config for a single action variant (stored in manifest/DB). */
+interface ActionVariantConfig {
+    schema: Record<string, unknown>;
+    webhook?: string;
+    hasHandler: boolean;
+}
+/** Serializable portion of action definitions (stored in agent config). */
+interface PlatformActionsConfig {
+    variants: Record<string, ActionVariantConfig>;
+}
+/** Full action definitions including in-memory schemas and handlers for runtime use. */
+interface PlatformActions {
+    readonly __type: "PlatformActions";
+    readonly config: PlatformActionsConfig;
+    readonly zodSchemas: Record<string, z.ZodObject<z.ZodRawShape>>;
+    readonly handlers: Readonly<Record<string, (payload: unknown) => Promise<void>>>;
+}
+declare const actionVariantConfigSchema: z.ZodObject<{
+    schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    webhook: z.ZodOptional<z.ZodString>;
+    hasHandler: z.ZodBoolean;
+}, z.core.$strip>;
+declare const actionsConfigSchema: 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>;
+
+declare const environmentSchema: z.ZodEnum<{
+    dev: "dev";
+    staging: "staging";
+    prod: "prod";
+}>;
+type Environment = z.infer<typeof environmentSchema>;
+
+declare const jitPolicySchema: z.ZodEnum<{
+    "auto-approve": "auto-approve";
+    "policy-based": "policy-based";
+    "require-approval": "require-approval";
+}>;
+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>;
+}, z.core.$strip>;
+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>;
+}, z.core.$strip>;
+type NotificationConfig = z.infer<typeof notificationConfigSchema>;
+
+/**
+ * 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";
+ *   }
+ * }
+ * ```
+ */
+interface KrakenTypeRegistry {
+}
+/** Remote agent IDs. Resolves to an error hint before `kraken generate`. */
+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`. */
+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`. */
+type SkillId = KrakenTypeRegistry extends {
+    skillId: infer T extends string;
+} ? T : "ERROR: Run 'kraken generate' to unlock skill IDs";
+
+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>;
+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>>;
+    trigger: 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>;
+type PlatformAgentConfig = Omit<z.infer<typeof platformAgentConfigSchema>, "agent" | "actions"> & {
+    agent: AgentDefinition;
+    actions?: PlatformActionsConfig;
+};
+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, z.ZodObject<z.ZodRawShape>>;
+    /** Action handler functions. Not serialized — runtime use only. */
+    readonly actionHandlers?: Readonly<Record<string, (payload: unknown) => Promise<void>>>;
+    /** Team member PlatformAgent objects. Not serialized — runtime use only (dev mode delegation). */
+    readonly teamAgents?: readonly PlatformAgent[];
+}
+/** Team member reference: local PlatformAgent or remote AgentId string. */
+type TeamMember = PlatformAgent | AgentId;
+
+interface PlatformSkill {
+    readonly __type: "PlatformSkill";
+    readonly name: string;
+    readonly description?: string;
+}
+
+/** 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>;
+}, z.core.$strip>;
+type ResourceLimits = z.infer<typeof resourceLimitsSchema>;
+declare const retryPolicySchema: z.ZodObject<{
+    maxAttempts: z.ZodOptional<z.ZodNumber>;
+    backoffSeconds: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type RetryPolicy = z.infer<typeof retryPolicySchema>;
+declare const concurrencyPolicySchema: z.ZodObject<{
+    maxParallelRuns: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type ConcurrencyPolicy = z.infer<typeof concurrencyPolicySchema>;
+
+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>;
+}, 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[];
+}) | {
+    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;
+    };
+}) => PlatformAgent & {
+    outputSchema?: TOutput;
+};
+
+/**
+ * Define an action variant.
+ *
+ * Infers handler payload types from the schema.
+ *
+ * @example
+ * ```ts
+ * defineAction({
+ *   schema: z.object({ reason: z.string() }),
+ *   handler: async (payload) => {
+ *     payload.reason; // string — fully typed
+ *   },
+ * });
+ * ```
+ */
+declare const defineAction: <S extends z.ZodObject<z.ZodRawShape>>(input: ActionVariantInput<S>) => ActionVariantInput<S>;
+/**
+ * Define action variants for a platform agent. Actions are typed terminal
+ * outputs — the agent's final decision as structured output.
+ *
+ * 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.
+ *
+ * Handler payload types are inferred from the schema automatically:
+ *
+ * @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() }) },
+ * });
+ * ```
+ */
+declare const defineActions: <V extends Record<string, ActionVariantInput>>(variants: V) => PlatformActions;
+/**
+ * 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.
+ */
+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">;
+
+/**
+ * Define a connector tool.
+ *
+ * Infers handler arg types from the `input` schema.
+ */
+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;
+}) => 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---";
+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>>;
+            trigger: 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>>;
+}, z.core.$strip>;
+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 const runDev: (agent: PlatformAgent) => Promise<never>;
+
+interface PlatformClientConfig {
+    baseUrl: string;
+    apiKey: string;
+}
+interface PaginationParams {
+    cursor?: string;
+    limit?: number;
+}
+interface PaginatedResponse<T> {
+    data: T[];
+    cursor: string | null;
+    hasMore: boolean;
+}
+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;
+};
+interface AgentInfo {
+    id: string;
+    name: string;
+    description?: string;
+}
+interface ThreadInfo {
+    id: string;
+    agentId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+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;
+    };
+}
+interface QueryInfo {
+    name: string;
+    description?: string;
+    params: Record<string, unknown>;
+    columns: QueryColumn[];
+}
+interface QueryColumn {
+    name: string;
+    type: string;
+    description?: string;
+}
+interface QueryResult<TRow = Record<string, unknown>> {
+    rows: TRow[];
+    cursor: string | null;
+    hasMore: boolean;
+}
+type RunState = "QUEUED" | "PROVISIONING" | "RUNNING" | "DRAINING" | "COMPLETED" | "FAILED" | "AWAITING_APPROVAL" | "RETRYING";
+interface RunRecord {
+    runId: string;
+    agentId: string;
+    input: string;
+    state: RunState;
+    exitCode?: number;
+    createdAt: string;
+    updatedAt: string;
+    retryCount: number;
+    error?: string;
+}
+interface StartRunParams {
+    agentId: string;
+    tag?: string;
+    environment?: "dev" | "staging" | "prod";
+    input: string;
+    connectors?: string[];
+    envVars?: Record<string, string>;
+}
+interface RunEvent {
+    eventId: string;
+    eventType: string;
+    payload: Record<string, unknown>;
+}
+interface AgentSchema {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+    output: Record<string, unknown>;
+    actions?: Record<string, Record<string, unknown>>;
+}
+interface QuerySchema$1 {
+    name: string;
+    params: Record<string, unknown>;
+    columns: QueryColumn[];
+}
+interface ConnectorSchema {
+    id: string;
+    tools: Array<{
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    }>;
+}
+interface SkillSchema {
+    id: string;
+    name: string;
+    description?: string;
+}
+
+type ToolOverride = (args: Record<string, unknown>) => Promise<unknown> | unknown;
+declare class MockToolSet {
+    private readonly defs;
+    private readonly overrides;
+    private readonly toolNames;
+    constructor(tools: ToolDefinition[], overrides?: Record<string, ToolOverride>);
+    static fromConnectors(connectors: ConnectorSchema[], opts?: {
+        include?: string[];
+        overrides?: Record<string, ToolOverride>;
+    }): MockToolSet;
+    definitions(): ToolDefinition[];
+    call(name: string, params: Record<string, unknown>): Promise<unknown>;
+}
+
+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;
+}
+
+interface AgentRegistryEntry {
+    input: unknown;
+    output: unknown;
+    actions: Record<string, unknown>;
+}
+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>>;
+}
+
+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>>;
+}
+
+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>>;
+}
+
+interface QuerySchema<P extends z.ZodType, R extends z.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>[]>;
+}
+
+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>;
+}
+
+declare class PlatformClient {
+    readonly agents: AgentsNamespace;
+    readonly data: DataNamespace;
+    readonly pipelines: PipelinesNamespace;
+    readonly runs: RunsNamespace;
+    private readonly http;
+    constructor(config: PlatformClientConfig);
+    agent<T extends AgentRegistryEntry = AgentRegistryEntry>(id: string, opts?: {
+        mode?: "local" | "remote";
+        threadId?: string;
+    }): AgentHandle<T>;
+}
+
+export { ACTION_NAME_REGEX, type ActionVariantConfig, type ActionVariantInput, type AgentDefinition, type AgentEvent, AgentHandle, type AgentId, type AgentInfo, type AgentRegistryEntry, type AgentSchema, AgentThread, type ConcurrencyPolicy, ConnectorDefinition, ConnectorError, type ConnectorId, type ConnectorRef, type ConnectorSchema, ConnectorToolDef, type Environment, type GenerateOpts, type GenerateResult, type IdentityConfig, type JitPolicy, type KrakenTypeRegistry, MANIFEST_END, MANIFEST_START, McpContent, MockToolSet, type NotificationConfig, type PaginatedResponse, type PaginationParams, type PlatformActions, type PlatformActionsConfig, type PlatformAgent, type PlatformAgentConfig, PlatformClient, type PlatformClientConfig, PlatformConnector, PlatformError, type PlatformSkill, type ProjectManifest, type QueryColumn, type QueryInfo, type QueryResult, type QuerySchema$1 as QuerySchema, type ResourceLimits, type RetryPolicy, type RunEvent, type RunRecord, type RunState, SecurityError, type SkillId, type SkillRef, type SkillSchema, type StartRunParams, type TeamConfig, type TeamMember, type ThreadInfo, type ThreadMessage, type TriggerConfig, actionVariantConfigSchema, actionsConfigSchema, agentDefinitionSchema, buildActionOutputSchema, concurrencyPolicySchema, defineAction, defineActions, defineConnector, definePlatformAgent, defineSkill, defineTool, environmentSchema, identityConfigSchema, isValidActionName, jitPolicySchema, mcpResult, notificationConfigSchema, parseManifestFromOutput, platformAgentConfigSchema, projectManifestSchema, resourceLimitsSchema, retryPolicySchema, runDev, teamConfigSchema, triggerConfigSchema, wrapToolError, wrapToolResult };