@caplets/core 0.19.0 → 0.20.0

package/dist/cli/auth.d.ts

@@ -1,5 +1,5 @@
 import { type GenericAuthTarget } from "../auth";
-import { loadConfig, type CapletsConfig, type GraphQlEndpointConfig, type HttpApiConfig } from "../config";
+import { loadConfig, type CapletsConfig } from "../config";
 type AuthTarget = ReturnType<typeof authTargets>[number];
 type AuthListFormat = "plain" | "markdown" | "json";
 export type AuthSource = "project" | "global" | "remote";
@@ -63,6 +63,44 @@ export declare function localAuthConfigForTarget(options: {
 }): CapletsConfig;
 export declare function formatAuthRows(rows: AuthStatusRow[], format: Exclude<AuthListFormat, "json">): string;
 export declare function findAuthTarget(serverId: string, config?: CapletsConfig): AuthTarget | undefined;
-declare function authTargets(config: ReturnType<typeof loadConfig>): (import("../config").CapletServerConfig | import("../config").OpenApiEndpointConfig | (GraphQlEndpointConfig & GenericAuthTarget) | (HttpApiConfig & GenericAuthTarget))[];
+declare function authTargets(config: ReturnType<typeof loadConfig>): (import("../config").CapletServerConfig | import("../config").OpenApiEndpointConfig | (import("../config").AgentSelectionHintsConfig & {
+    server: string;
+    backend: "graphql";
+    name: string;
+    description: string;
+    exposure?: import("../config").CapletExposure | undefined;
+    tags?: string[] | undefined;
+    body?: string | undefined;
+    endpointUrl: string;
+    schemaPath?: string | undefined;
+    schemaUrl?: string | undefined;
+    introspection?: true | undefined;
+    operations?: Record<string, import("../config").GraphQlOperationConfig> | undefined;
+    auth: import("../config").OpenApiAuthConfig;
+    requestTimeoutMs: number;
+    operationCacheTtlMs: number;
+    selectionDepth: number;
+    disabled: boolean;
+    setup?: import("..").CapletSetupConfig | undefined;
+    projectBinding?: import("../config").ProjectBindingConfig | undefined;
+    runtime?: import("../config").RuntimeRequirementsConfig | undefined;
+} & GenericAuthTarget) | (import("../config").AgentSelectionHintsConfig & {
+    server: string;
+    backend: "http";
+    name: string;
+    description: string;
+    exposure?: import("../config").CapletExposure | undefined;
+    tags?: string[] | undefined;
+    body?: string | undefined;
+    baseUrl: string;
+    auth: import("../config").OpenApiAuthConfig;
+    actions: Record<string, import("../config").HttpActionConfig>;
+    requestTimeoutMs: number;
+    maxResponseBytes: number;
+    disabled: boolean;
+    setup?: import("..").CapletSetupConfig | undefined;
+    projectBinding?: import("../config").ProjectBindingConfig | undefined;
+    runtime?: import("../config").RuntimeRequirementsConfig | undefined;
+} & GenericAuthTarget))[];
 export declare function assertLoginTarget(target: AuthTarget | undefined, serverId: string): asserts target is AuthTarget;
 export {};

package/dist/cli/cloud-add.d.ts

@@ -0,0 +1,8 @@
+export type CloudCapletBundleFile = {
+    path: string;
+    content: string;
+};
+export type CloudCapletBundle = {
+    files: CloudCapletBundleFile[];
+};
+export declare function buildCloudCapletBundle(rootInput: string): CloudCapletBundle;

package/dist/cli/code-mode.d.ts

@@ -0,0 +1,16 @@
+export type CodeModeCliOptions = {
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    configPath?: string | undefined;
+    projectConfigPath?: string | undefined;
+    authDir?: string | undefined;
+    inlineCode?: string | undefined;
+    file?: string | undefined;
+    timeoutMs?: number | undefined;
+    json?: boolean | undefined;
+    readStdin?: (() => Promise<string>) | undefined;
+    writeOut: (value: string) => void;
+    setExitCode: (code: number) => void;
+};
+export declare function runCodeModeCli(options: CodeModeCliOptions): Promise<void>;
+export declare function codeModeTypesCli(options: Pick<CodeModeCliOptions, "env" | "configPath" | "projectConfigPath" | "authDir" | "json" | "writeOut">): Promise<void>;
+export declare function readCodeModeCliCode(options: Pick<CodeModeCliOptions, "inlineCode" | "file" | "readStdin">): Promise<string>;

package/dist/cli/commands.d.ts

@@ -3,6 +3,7 @@ export type CompletionShell = (typeof completionShells)[number];
 export declare const cliCommands: {
     readonly completion: "completion";
     readonly completeHidden: "__complete";
+    readonly codeMode: "code-mode";
     readonly serve: "serve";
     readonly attach: "attach";
     readonly cloud: "cloud";
@@ -29,11 +30,12 @@ export declare const cliCommands: {
     readonly config: "config";
     readonly auth: "auth";
 };
-export declare const topLevelCommandNames: readonly ["serve", "attach", "cloud", "init", "setup", "doctor", "list", "install", "add", "inspect", "check-backend", "list-tools", "search-tools", "get-tool", "call-tool", "list-resources", "search-resources", "list-resource-templates", "read-resource", "list-prompts", "search-prompts", "get-prompt", "complete", "config", "auth", "completion"];
+export declare const topLevelCommandNames: readonly ["serve", "code-mode", "attach", "cloud", "init", "setup", "doctor", "list", "install", "add", "inspect", "check-backend", "list-tools", "search-tools", "get-tool", "call-tool", "list-resources", "search-resources", "list-resource-templates", "read-resource", "list-prompts", "search-prompts", "get-prompt", "complete", "config", "auth", "completion"];
 export declare const cliSubcommands: {
     readonly add: readonly ["cli", "mcp", "openapi", "graphql", "http"];
     readonly auth: readonly ["login", "logout", "list"];
     readonly cloud: readonly ["auth"];
+    readonly "code-mode": readonly ["types"];
     readonly completion: readonly ["bash", "zsh", "fish", "powershell", "cmd"];
     readonly config: readonly ["path", "paths"];
     readonly serve: readonly ["start", "stop", "status", "restart", "enable", "disable"];

package/dist/cli/doctor.d.ts

@@ -5,6 +5,7 @@ export type DoctorOptions = {
     cwd?: string;
     syncStatus?: MutagenProjectSyncDoctorData;
     cloudAuthStore?: CloudAuthStore;
+    observedOutputShapeCacheDir?: string;
 };
 export type DoctorJsonReport = {
     server: Record<string, unknown>;
@@ -13,6 +14,8 @@ export type DoctorJsonReport = {
     sync: Record<string, unknown>;
     daemon: Record<string, unknown>;
     cloudAuth: Record<string, unknown>;
+    exposure: Record<string, unknown>;
+    codeMode: Record<string, unknown>;
 };
 export declare function doctorJsonReport(options?: DoctorOptions): Promise<DoctorJsonReport>;
 export declare function formatDoctorReport(options?: DoctorOptions): Promise<string>;

package/dist/cli/setup.d.ts

@@ -8,8 +8,10 @@ export type SetupCommandResult = {
     stderr: string;
 };
 export type SetupCommandRunner = (command: string, args: string[]) => Promise<SetupCommandResult>;
+export type SetupPromptReader = (prompt: string) => Promise<string>;
 export type SetupOptions = {
     remote?: boolean;
+    remoteUrl?: string;
     serverUrl?: string;
     output?: string;
     dryRun?: boolean;
@@ -19,5 +21,10 @@ export type SetupOptions = {
     yes?: boolean;
     target?: SetupTargetOption;
 };
+export type InteractiveSetupOptions = SetupOptions & {
+    readPrompt: SetupPromptReader;
+};
 export declare function formatSetupMenu(): string;
+export declare function formatSetupPrompt(): string;
+export declare function runInteractiveSetup(options: InteractiveSetupOptions): Promise<string>;
 export declare function runSetup(integration: string, options?: SetupOptions): Promise<string>;

package/dist/cli-tools.d.ts

@@ -1,6 +1,6 @@
 import type { CompatibilityCallToolResult, Tool } from "@modelcontextprotocol/sdk/types";
 import type { CliToolsConfig } from "./config";
-import type { CompactTool } from "./downstream";
+import { type CompactTool } from "./downstream";
 import type { ServerRegistry } from "./registry";
 export declare class CliToolsManager {
     private registry;

package/dist/cli.d.ts

@@ -20,6 +20,7 @@ type CliIO = {
     attachServe?: (options: AttachServeOptions) => Promise<void>;
     daemon?: ServeDaemonOperationOptions;
     runSetupCommand?: SetupCommandRunner;
+    readStdin?: () => Promise<string>;
 };
 export declare function runCli(args: string[], io?: CliIO): Promise<void>;
 export declare function createProgram(io?: CliIO): Command;

package/dist/cloud-auth/client.d.ts

@@ -15,6 +15,20 @@ export type ExchangeTokenInput = {
 export type RefreshTokenInput = {
     refreshToken: string;
 };
+export type CloudAddCapletsInput = {
+    accessToken: string;
+    workspace: string;
+    bundle: {
+        files: Array<{
+            path: string;
+            content: string;
+        }>;
+    };
+};
+export type CloudAddCapletsResult = {
+    caplet?: unknown;
+    caplets: unknown[];
+};
 export type CloudAuthClientCredentials = Required<Pick<CloudAuthTokenResponse, "workspaceId" | "accessToken" | "expiresAt" | "tokenType" | "credentialFamilyId">> & Pick<CloudAuthTokenResponse, "workspaceSlug" | "refreshToken" | "deviceName" | "requestId"> & {
     cloudUrl: string;
     scope: string[];
@@ -38,5 +52,6 @@ export declare class CloudAuthClient {
         refreshToken?: string | undefined;
         deviceName?: string | undefined;
     }): Promise<CloudAuthClientCredentials>;
+    addCaplets(input: CloudAddCapletsInput): Promise<CloudAddCapletsResult>;
     private requestJson;
 }

package/dist/cloud-auth/types.d.ts

@@ -1,6 +1,7 @@
 export declare const CLOUD_AUTH_STATES: readonly ["unauthenticated", "login_pending", "workspace_selection_required", "authenticated", "refreshable", "switch_required", "expired", "revoked"];
 export type CloudAuthState = (typeof CLOUD_AUTH_STATES)[number];
-export type CloudAuthScope = "project_binding:read" | "project_binding:write" | string;
+export declare const HOSTED_CLOUD_AUTH_SCOPES: readonly ["project_binding:read", "project_binding:write", "mcp:tools"];
+export type CloudAuthScope = (typeof HOSTED_CLOUD_AUTH_SCOPES)[number] | string;
 export type CloudAuthWorkspace = {
     workspaceId: string;
     slug?: string | undefined;

package/dist/code-mode/api.d.ts

@@ -0,0 +1,32 @@
+import type { NativeCapletsService } from "../native/service";
+import type { CapletsResult, CodeModeCallableCaplet, Page, PageInput, ReadLogsInput, ReadLogsResult, ToolCallResult } from "./types";
+export type CodeModeCapletHandle = {
+    readonly id: string;
+    inspect(): Promise<unknown>;
+    check(): Promise<CapletsResult<unknown>>;
+    tools(input?: PageInput): Promise<Page<unknown>>;
+    searchTools(query: string, input?: PageInput): Promise<Page<unknown>>;
+    describeTool(name: string): Promise<CapletsResult<unknown>>;
+    callTool(name: string, args?: unknown): Promise<ToolCallResult>;
+    resources(input?: PageInput): Promise<Page<unknown>>;
+    searchResources(query: string, input?: PageInput): Promise<Page<unknown>>;
+    resourceTemplates(input?: PageInput): Promise<Page<unknown>>;
+    readResource(uri: string): Promise<CapletsResult<unknown>>;
+    prompts(input?: PageInput): Promise<Page<unknown>>;
+    searchPrompts(query: string, input?: PageInput): Promise<Page<unknown>>;
+    getPrompt(name: string, args?: unknown): Promise<CapletsResult<unknown>>;
+    complete(input: unknown): Promise<CapletsResult<unknown>>;
+};
+export type CodeModeDebugApi = {
+    readLogs(input: ReadLogsInput): Promise<ReadLogsResult>;
+};
+export type CodeModeCapletsApi = {
+    [capletId: string]: CodeModeCapletHandle | CodeModeDebugApi | (CodeModeCapletHandle & CodeModeDebugApi);
+    debug: CodeModeDebugApi | (CodeModeCapletHandle & CodeModeDebugApi);
+};
+export type CreateCodeModeCapletsApiInput = {
+    service: NativeCapletsService;
+    readLogs?: (input: ReadLogsInput) => Promise<ReadLogsResult>;
+};
+export declare function listCodeModeCallableCaplets(service: NativeCapletsService): CodeModeCallableCaplet[];
+export declare function createCodeModeCapletsApi(input: CreateCodeModeCapletsApiInput): CodeModeCapletsApi;

package/dist/code-mode/declarations.d.ts

@@ -0,0 +1,5 @@
+import type { CodeModeDeclarationInput } from "./types";
+export declare function generateCodeModeDeclarations(input: CodeModeDeclarationInput): string;
+export declare function generateCodeModeRunToolDescription(declaration: string): string;
+export declare function minifyCodeModeDeclarationText(value: string): string;
+export declare function codeModeDeclarationHash(declaration: string): string;

package/dist/code-mode/diagnostics.d.ts

@@ -0,0 +1,8 @@
+import type { CodeModeDiagnostic } from "./types";
+export type DiagnoseCodeModeTypeScriptInput = {
+    code: string;
+    declaration: string;
+    maxDiagnostics?: number;
+    timeoutMs?: number;
+};
+export declare function diagnoseCodeModeTypeScript(input: DiagnoseCodeModeTypeScriptInput): CodeModeDiagnostic[];

package/dist/code-mode/index.d.ts

@@ -0,0 +1,4 @@
+export { codeModeDeclarationHash, generateCodeModeDeclarations, generateCodeModeRunToolDescription, minifyCodeModeDeclarationText, } from "./declarations";
+export { codeModeRunInputJsonSchema, codeModeRunInputSchema, codeModeRunParamsSchema, isCodeModeRunRequest, } from "./tool";
+export { hasDirectFetchCall, hasExecutableImport } from "./static-analysis";
+export type { CodeModeCallableCaplet, CodeModeDeclarationInput, CodeModeDiagnostic, CodeModeLogEntry, CodeModeLogs, CodeModeRunEnvelope, CodeModeRunError, CodeModeRunMeta, CodeModeTypesJson, JsonPrimitive, JsonValue, ReadLogsInput, ReadLogsResult, ToolCallError, ToolCallMeta, ToolCallResult, } from "./types";

package/dist/code-mode/logs.d.ts

@@ -0,0 +1,21 @@
+import type { CodeModeLogEntry, ReadLogsInput, ReadLogsResult } from "./types";
+export type CodeModeLogStoreOptions = {
+    stateDir?: string;
+    now?: () => Date;
+    logRefTtlMs?: number;
+};
+export type StoreCodeModeLogsResult = {
+    logRef: string;
+    expiresAt: string;
+};
+export declare class CodeModeLogStore {
+    private readonly stateDir;
+    private readonly now;
+    private readonly logRefTtlMs;
+    constructor(options?: CodeModeLogStoreOptions);
+    store(entries: CodeModeLogEntry[]): Promise<StoreCodeModeLogsResult>;
+    read(input: ReadLogsInput): Promise<ReadLogsResult>;
+    private logsDir;
+    private logPath;
+}
+export declare function redactCodeModeLogText(text: string): string;

package/dist/code-mode/runner.d.ts

@@ -0,0 +1,15 @@
+import type { NativeCapletsService } from "../native/service";
+import { CodeModeLogStore } from "./logs";
+import { type CodeModeSandbox } from "./sandbox";
+import type { CodeModeRunEnvelope } from "./types";
+export type RunCodeModeInput = {
+    code: string;
+    service: NativeCapletsService;
+    timeoutMs?: number;
+    maxTimeoutMs?: number;
+    runtimeScope?: string;
+    logStore?: CodeModeLogStore;
+    sandbox?: CodeModeSandbox;
+    returnedLogBytes?: number;
+};
+export declare function runCodeMode(input: RunCodeModeInput): Promise<CodeModeRunEnvelope>;

package/dist/code-mode/runtime-api.generated.d.ts

@@ -0,0 +1 @@
+export declare const CODE_MODE_RUNTIME_API_DECLARATION: "type JsonPrimitive=string|number|boolean|null;type JsonValue=JsonPrimitive|JsonValue[]|{[key:string]:JsonValue};interface CapletHandle<Id extends string>{readonly id:Id;/** Show this Caplet card,without tool/resource/prompt schemas. */ inspect():Promise<CapletCard<Id>>;/** Check backend readiness/auth;expected unavailable states return ok:false. */ check():Promise<CapletsResult<BackendCheckResult>>;/** List tool summaries for the discovery pass;may be empty. */ tools(input?:PageInput):Promise<Page<ToolSummary>>;/** Search tool summaries for the discovery pass;may be empty. */ searchTools(query:string,input?:PageInput):Promise<Page<ToolSummary>>;/** Get schema,callSignature,types,examples;prefer outputSchema/outputTypeScript over observed hints. */ describeTool(name:string):Promise<CapletsResult<ToolDescriptor>>;/** Call one tool;expected failures return ok:false. Filter bulky data in script before returning. */ callTool(name:string,args?:unknown):Promise<CapletsResult<unknown>>;/** List readable resources for the discovery pass;many backends expose none. */ resources(input?:PageInput):Promise<Page<ResourceSummary>>;/** Search readable resources for the discovery pass;many backends expose none. */ searchResources(query:string,input?:PageInput):Promise<Page<ResourceSummary>>;/** List resource templates for the discovery pass;many backends expose none. */ resourceTemplates(input?:PageInput):Promise<Page<ResourceTemplateSummary>>;/** Read one resource by URI;unsupported/missing resources return ok:false. */ readResource(uri:string):Promise<CapletsResult<ResourceReadResult>>;/** List reusable prompts for the discovery pass;many backends expose none. */ prompts(input?:PageInput):Promise<Page<PromptSummary>>;/** Search reusable prompts for the discovery pass;many backends expose none. */ searchPrompts(query:string,input?:PageInput):Promise<Page<PromptSummary>>;/** Get one prompt by name and args;unsupported/missing prompts return ok:false. */ getPrompt(name:string,args?:unknown):Promise<CapletsResult<PromptResult>>;/** Complete a prompt or resource-template argument. */ complete(input:CompleteInput):Promise<CapletsResult<CompleteResult>>;}interface DebugApi{readLogs(input:ReadLogsInput):Promise<ReadLogsResult>;}type CapletCard<Id extends string>={id:Id;name:string;description:string;useWhen?:string;avoidWhen?:string;tags?:string[];backend?:unknown;};type PageInput={limit?:number;cursor?:string};type Page<T>={items:T[];nextCursor?:string;truncated?:boolean};type CapletsResult<T>=|{ok:true;data:T;meta?:CapletsMeta}|{ok:false;error:CapletsError;meta?:CapletsMeta};type CapletsMeta={[key:string]:unknown};type CapletsError={code:string;message:string;details?:unknown};type BackendCheckResult=unknown;type ToolSummary={/** Exact downstream tool identifier for describeTool(name)and callTool(name,args). */ name:string;title?:string;description?:string;/** Optional author-supplied hint for when to prefer this tool. */ useWhen?:string;/** Optional author-supplied hint for when to avoid this tool. */ avoidWhen?:string;/** True when the tool declares that it only reads data. */ readOnlyHint?:boolean;/** True when the tool declares that it may perform destructive writes. */ destructiveHint?:boolean;};type ToolDescriptor={id?:string;tool?:unknown;inputSchema?:unknown;outputSchema?:unknown;callSignature?:string;inputTypeScript?:string;outputTypeScript?:string;observedOutputShape?:ObservedOutputShape;examples?:unknown[];};type ObservedOutputShape={version:1;source:\"observed\";observedAt:string;sampleCount:number;typeScript:string;jsonShape:JsonShape;truncated:boolean;};type JsonShape=|{kind:\"null\"}|{kind:\"boolean\"}|{kind:\"number\"}|{kind:\"string\"}|{kind:\"unknown\"}|{kind:\"array\";element?:JsonShape;truncated?:boolean}|{kind:\"object\";fields:Record<string,{optional:boolean;shape:JsonShape}>;truncated?:boolean;}|{kind:\"union\";variants:JsonShape[]};type ResourceSummary={uri?:string;name?:string;title?:string;description?:string};type ResourceTemplateSummary={uriTemplate?:string;name?:string;title?:string;description?:string;};type ResourceReadResult=unknown;type PromptSummary={name?:string;title?:string;description?:string};type PromptResult=unknown;type CompleteInput={ref:{type:\"prompt\";name:string}|{type:\"resourceTemplate\";uri:string};argument:{name:string;value:string};};type CompleteResult=unknown;type ReadLogsInput={logRef:string;cursor?:string;limit?:number};type ReadLogsResult={entries:CodeModeLogEntry[];nextCursor?:string};type CodeModeLogEntry={level:\"log\"|\"info\"|\"warn\"|\"error\"|\"debug\";message:string;timestamp:string;};interface Console{log(...values:unknown[]):void;info(...values:unknown[]):void;warn(...values:unknown[]):void;error(...values:unknown[]):void;debug(...values:unknown[]):void;}declare const console:Console;";

package/dist/code-mode/sandbox.d.ts

@@ -0,0 +1,28 @@
+import type { CodeModeLogEntry } from "./types";
+export type CodeModeSandboxInvokeInput = {
+    capletId: string;
+    method: "inspect" | "check" | "tools" | "searchTools" | "describeTool" | "callTool" | "resources" | "searchResources" | "resourceTemplates" | "readResource" | "prompts" | "searchPrompts" | "getPrompt" | "complete" | "readLogs";
+    args: unknown[];
+};
+export type CodeModeSandboxInput = {
+    code: string;
+    capletIds: string[];
+    timeoutMs: number;
+    invoke: (input: CodeModeSandboxInvokeInput) => Promise<unknown>;
+};
+export type CodeModeSandboxResult = {
+    ok: true;
+    value: unknown;
+    logs: CodeModeLogEntry[];
+} | {
+    ok: false;
+    error: string;
+    logs: CodeModeLogEntry[];
+    stack?: string;
+};
+export interface CodeModeSandbox {
+    run(input: CodeModeSandboxInput): Promise<CodeModeSandboxResult>;
+}
+export declare class QuickJsCodeModeSandbox implements CodeModeSandbox {
+    run(input: CodeModeSandboxInput): Promise<CodeModeSandboxResult>;
+}

package/dist/code-mode/static-analysis.d.ts

@@ -0,0 +1,2 @@
+export declare function hasDirectFetchCall(code: string): boolean;
+export declare function hasExecutableImport(code: string): boolean;

package/dist/code-mode/tool.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const codeModeRunInputSchema: z.ZodObject<{
+    code: z.ZodString;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const codeModeRunParamsSchema: {
+    code: z.ZodString;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+};
+export declare function codeModeRunInputJsonSchema(): Record<string, unknown>;
+export declare function isCodeModeRunRequest(value: unknown): boolean;

package/dist/code-mode/types.d.ts

@@ -0,0 +1,120 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type CodeModeCallableCaplet = {
+    id: string;
+    name: string;
+    description: string;
+    useWhen?: string;
+    avoidWhen?: string;
+};
+export type CodeModeDeclarationInput = {
+    caplets: CodeModeCallableCaplet[];
+};
+export type CodeModeTypesJson = {
+    declaration: string;
+    declarationHash: string;
+    callableCount: number;
+    generatedAt: string;
+    runtimeScope: string;
+};
+export type CodeModeDiagnostic = {
+    code: string;
+    message: string;
+    severity: "error" | "warning" | "info";
+    line?: number;
+    column?: number;
+};
+export type CodeModeRunMeta = {
+    runId: string;
+    traceId: string;
+    declarationHash: string;
+    durationMs: number;
+    timeoutMs: number;
+    maxTimeoutMs: number;
+};
+export type CodeModeRunError = {
+    code: string;
+    message: string;
+    details?: unknown;
+    location?: {
+        line: number;
+        column: number;
+    };
+    hint?: string;
+    stackPreview?: string[];
+};
+export type CodeModeLogEntry = {
+    level: "log" | "info" | "warn" | "error" | "debug";
+    message: string;
+    timestamp: string;
+};
+export type CodeModeLogs = {
+    entries: CodeModeLogEntry[];
+    truncated: boolean;
+    stored: boolean;
+    logRef?: string;
+    nextCursor?: string;
+    expiresAt?: string;
+};
+export type CodeModeRunEnvelope = {
+    ok: true;
+    value: JsonValue;
+    diagnostics: CodeModeDiagnostic[];
+    logs: CodeModeLogs;
+    meta: CodeModeRunMeta;
+} | {
+    ok: false;
+    error: CodeModeRunError;
+    diagnostics: CodeModeDiagnostic[];
+    logs: CodeModeLogs;
+    meta: CodeModeRunMeta;
+};
+export type ToolCallMeta = {
+    capletId?: string;
+    tool?: string;
+    durationMs?: number;
+    [key: string]: unknown;
+};
+export type ToolCallError = {
+    code: string;
+    message: string;
+    details?: unknown;
+};
+export type ToolCallResult = {
+    ok: true;
+    data: unknown;
+    meta?: ToolCallMeta;
+} | {
+    ok: false;
+    error: ToolCallError;
+    meta?: ToolCallMeta;
+};
+export type CapletsResult<T> = {
+    ok: true;
+    data: T;
+    meta?: ToolCallMeta;
+} | {
+    ok: false;
+    error: ToolCallError;
+    meta?: ToolCallMeta;
+};
+export type Page<T> = {
+    items: T[];
+    nextCursor?: string;
+    truncated?: boolean;
+};
+export type PageInput = {
+    limit?: number;
+    cursor?: string;
+};
+export type ReadLogsInput = {
+    logRef: string;
+    cursor?: string;
+    limit?: number;
+};
+export type ReadLogsResult = {
+    entries: CodeModeLogEntry[];
+    nextCursor?: string;
+};