@intentic/sandbox-contract 0.0.0 → 1.1.0

package/dist/contracts/activity.contract.d.ts

@@ -0,0 +1,51 @@
+export declare const activityContract: {
+    list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        provider: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
+        before: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        events: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            at: import("zod").ZodNumber;
+            provider: import("zod").ZodOptional<import("zod").ZodString>;
+            direction: import("zod").ZodEnum<{
+                out: "out";
+                in: "in";
+                system: "system";
+            }>;
+            type: import("zod").ZodString;
+            channelId: import("zod").ZodOptional<import("zod").ZodString>;
+            author: import("zod").ZodOptional<import("zod").ZodString>;
+            content: import("zod").ZodOptional<import("zod").ZodString>;
+            method: import("zod").ZodOptional<import("zod").ZodString>;
+            endpoint: import("zod").ZodOptional<import("zod").ZodString>;
+            sessionId: import("zod").ZodOptional<import("zod").ZodString>;
+            automationIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            outcome: import("zod").ZodOptional<import("zod").ZodEnum<{
+                error: "error";
+                ok: "ok";
+            }>>;
+            error: import("zod").ZodOptional<import("zod").ZodString>;
+            extra: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    status: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        connections: import("zod").ZodArray<import("zod").ZodObject<{
+            capabilityId: import("zod").ZodString;
+            provider: import("zod").ZodString;
+            gateway: import("zod").ZodEnum<{
+                ready: "ready";
+                connecting: "connecting";
+                disconnected: "disconnected";
+            }>;
+            lastError: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        voice: import("zod").ZodOptional<import("zod").ZodObject<{
+            channelId: import("zod").ZodString;
+            channelName: import("zod").ZodString;
+            startedAt: import("zod").ZodNumber;
+            participants: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+};
+//# sourceMappingURL=activity.contract.d.ts.map

package/dist/contracts/activity.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/activity.contract.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG5B,CAAC"}

package/dist/contracts/activity.contract.js

@@ -0,0 +1,7 @@
+import { oc } from "@orpc/contract";
+import { ActivityListSchema, ActivityQuerySchema, ActivityStatusSchema } from "../schemas.js";
+export const activityContract = {
+    list: oc.route({ method: "GET", path: "/activity" }).input(ActivityQuerySchema).output(ActivityListSchema),
+    status: oc.route({ method: "GET", path: "/activity/status" }).output(ActivityStatusSchema),
+};
+//# sourceMappingURL=activity.contract.js.map

package/dist/contracts/activity.contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.contract.js","sourceRoot":"","sources":["../../src/contracts/activity.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAI9F,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC5B,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC,MAAM,CAAC,kBAAkB,CAAC;IAC1G,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,CAAC,MAAM,CAAC,oBAAoB,CAAC;CAC7F,CAAC"}

package/dist/contracts/agent.contract.d.ts

@@ -1,6 +1,12 @@
 export declare const agentContract: {
     run: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
         prompt: import("zod").ZodString;
+        attachments: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        agent: import("zod").ZodOptional<import("zod").ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            grok: "grok";
+        }>>;
         sessionId: import("zod").ZodOptional<import("zod").ZodString>;
         model: import("zod").ZodOptional<import("zod").ZodString>;
         plan: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -9,13 +15,60 @@ export declare const agentContract: {
     }, import("zod/v4/core").$strip>, import("@orpc/contract").Schema<AsyncIteratorObject<{
         kind: "session";
         sessionId: string;
+    } | {
+        kind: "init";
+        model: string;
     } | {
         kind: "delta";
         text: string;
+        parentToolUseId?: string | undefined;
+    } | {
+        kind: "thinking";
+        text: string;
+        parentToolUseId?: string | undefined;
     } | {
         kind: "tool";
         name: string;
+        id?: string | undefined;
         target?: string | undefined;
+        parentToolUseId?: string | undefined;
+    } | {
+        kind: "tool_result";
+        output: string;
+        id?: string | undefined;
+        isError?: boolean | undefined;
+    } | {
+        kind: "terminal";
+        session: string;
+    } | {
+        kind: "todos";
+        items: {
+            content: string;
+            status: "pending" | "in_progress" | "completed";
+            activeForm?: string | undefined;
+        }[];
+    } | {
+        kind: "usage";
+        costUsd?: number | undefined;
+        inputTokens?: number | undefined;
+        outputTokens?: number | undefined;
+        durationMs?: number | undefined;
+        numTurns?: number | undefined;
+    } | {
+        status: "allowed" | "allowed_warning" | "rejected";
+        kind: "rate_limit_info";
+        resetsAt?: number | undefined;
+        rateLimitType?: string | undefined;
+        utilization?: number | undefined;
+    } | {
+        tokens: number;
+        contextWindow: number;
+        kind: "context_usage";
+    } | {
+        kind: "compact";
+        trigger: string;
+        preTokens?: number | undefined;
+        postTokens?: number | undefined;
     } | {
         kind: "plan";
         decisionId: string;
@@ -36,18 +89,66 @@ export declare const agentContract: {
     } | {
         kind: "error";
         message: string;
+        code?: "session-not-found" | "rate_limit" | undefined;
     } | {
         kind: "done";
     }, unknown, void>, import("@orpc/contract").AsyncIteratorClass<{
         kind: "session";
         sessionId: string;
+    } | {
+        kind: "init";
+        model: string;
     } | {
         kind: "delta";
         text: string;
+        parentToolUseId?: string | undefined;
+    } | {
+        kind: "thinking";
+        text: string;
+        parentToolUseId?: string | undefined;
     } | {
         kind: "tool";
         name: string;
+        id?: string | undefined;
         target?: string | undefined;
+        parentToolUseId?: string | undefined;
+    } | {
+        kind: "tool_result";
+        output: string;
+        id?: string | undefined;
+        isError?: boolean | undefined;
+    } | {
+        kind: "terminal";
+        session: string;
+    } | {
+        kind: "todos";
+        items: {
+            content: string;
+            status: "pending" | "in_progress" | "completed";
+            activeForm?: string | undefined;
+        }[];
+    } | {
+        kind: "usage";
+        costUsd?: number | undefined;
+        inputTokens?: number | undefined;
+        outputTokens?: number | undefined;
+        durationMs?: number | undefined;
+        numTurns?: number | undefined;
+    } | {
+        status: "allowed" | "allowed_warning" | "rejected";
+        kind: "rate_limit_info";
+        resetsAt?: number | undefined;
+        rateLimitType?: string | undefined;
+        utilization?: number | undefined;
+    } | {
+        tokens: number;
+        contextWindow: number;
+        kind: "context_usage";
+    } | {
+        kind: "compact";
+        trigger: string;
+        preTokens?: number | undefined;
+        postTokens?: number | undefined;
     } | {
         kind: "plan";
         decisionId: string;
@@ -68,6 +169,7 @@ export declare const agentContract: {
     } | {
         kind: "error";
         message: string;
+        code?: "session-not-found" | "rate_limit" | undefined;
     } | {
         kind: "done";
     }, unknown, void>>, Record<never, never>, Record<never, never>>;

package/dist/contracts/agent.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/agent.contract.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIzB,CAAC"}
+{"version":3,"file":"agent.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/agent.contract.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIzB,CAAC"}

package/dist/contracts/automations.contract.d.ts

@@ -0,0 +1,98 @@
+export declare const automationsContract: {
+    list: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        automations: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            trigger: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"schedule">;
+                cron: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"event">;
+                token: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"listener">;
+                provider: import("zod").ZodEnum<{
+                    discord: "discord";
+                    webchat: "webchat";
+                }>;
+                channelId: import("zod").ZodOptional<import("zod").ZodString>;
+                eventType: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    message: "message";
+                    voice_utterance: "voice_utterance";
+                    voice_transcript: "voice_transcript";
+                }>>;
+                mentioned: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                allowedOrigins: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            }, import("zod/v4/core").$strip>], "kind">;
+            guard: import("zod").ZodOptional<import("zod").ZodString>;
+            prompt: import("zod").ZodString;
+            model: import("zod").ZodOptional<import("zod").ZodString>;
+            requireApproval: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            enabled: import("zod").ZodBoolean;
+            runs: import("zod").ZodArray<import("zod").ZodObject<{
+                at: import("zod").ZodNumber;
+                outcome: import("zod").ZodEnum<{
+                    completed: "completed";
+                    error: "error";
+                    skipped: "skipped";
+                }>;
+                detail: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+            nextRun: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    upsert: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        trigger: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"schedule">;
+            cron: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"event">;
+            token: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"listener">;
+            provider: import("zod").ZodEnum<{
+                discord: "discord";
+                webchat: "webchat";
+            }>;
+            channelId: import("zod").ZodOptional<import("zod").ZodString>;
+            eventType: import("zod").ZodOptional<import("zod").ZodEnum<{
+                message: "message";
+                voice_utterance: "voice_utterance";
+                voice_transcript: "voice_transcript";
+            }>>;
+            mentioned: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            allowedOrigins: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strip>], "kind">;
+        guard: import("zod").ZodOptional<import("zod").ZodString>;
+        prompt: import("zod").ZodString;
+        model: import("zod").ZodOptional<import("zod").ZodString>;
+        requireApproval: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        enabled: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    remove: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    pendingList: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        approvals: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            automationId: import("zod").ZodString;
+            payload: import("zod").ZodOptional<import("zod").ZodString>;
+            createdAt: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    approve: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    reject: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+};
+//# sourceMappingURL=automations.contract.d.ts.map

package/dist/contracts/automations.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"automations.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/automations.contract.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAO/B,CAAC"}

package/dist/contracts/automations.contract.js

@@ -0,0 +1,11 @@
+import { oc } from "@orpc/contract";
+import { AutomationApprovalIdParamSchema, AutomationApprovalsListSchema, AutomationIdParamSchema, AutomationSchema, AutomationsListSchema, OkSchema, } from "../schemas.js";
+export const automationsContract = {
+    list: oc.route({ method: "GET", path: "/automations" }).output(AutomationsListSchema),
+    upsert: oc.route({ method: "POST", path: "/automations" }).input(AutomationSchema).output(OkSchema),
+    remove: oc.route({ method: "DELETE", path: "/automations/{id}" }).input(AutomationIdParamSchema).output(OkSchema),
+    pendingList: oc.route({ method: "GET", path: "/automations/pending" }).output(AutomationApprovalsListSchema),
+    approve: oc.route({ method: "POST", path: "/automations/pending/{id}/approve" }).input(AutomationApprovalIdParamSchema).output(OkSchema),
+    reject: oc.route({ method: "POST", path: "/automations/pending/{id}/reject" }).input(AutomationApprovalIdParamSchema).output(OkSchema),
+};
+//# sourceMappingURL=automations.contract.js.map

package/dist/contracts/automations.contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"automations.contract.js","sourceRoot":"","sources":["../../src/contracts/automations.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EACH,+BAA+B,EAC/B,6BAA6B,EAC7B,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,QAAQ,GACX,MAAM,eAAe,CAAC;AAOvB,MAAM,CAAC,MAAM,mBAAmB,GAAG;IAC/B,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC,CAAC,MAAM,CAAC,qBAAqB,CAAC;IACrF,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IACnG,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IACjH,WAAW,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,sBAAsB,EAAE,CAAC,CAAC,MAAM,CAAC,6BAA6B,CAAC;IAC5G,OAAO,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,mCAAmC,EAAE,CAAC,CAAC,KAAK,CAAC,+BAA+B,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IACxI,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,kCAAkC,EAAE,CAAC,CAAC,KAAK,CAAC,+BAA+B,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;CACzI,CAAC"}

package/dist/contracts/capabilities.contract.d.ts

@@ -0,0 +1,234 @@
+export declare const capabilitiesContract: {
+    list: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        capabilities: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            kind: import("zod").ZodEnum<{
+                service: "service";
+                devops: "devops";
+                monorepo: "monorepo";
+                mcp: "mcp";
+                integration: "integration";
+                cli: "cli";
+                plugin: "plugin";
+                ssh: "ssh";
+                vpn: "vpn";
+                docker: "docker";
+                browser: "browser";
+            }>;
+            status: import("zod").ZodObject<{
+                state: import("zod").ZodEnum<{
+                    pending: "pending";
+                    error: "error";
+                    active: "active";
+                    inactive: "inactive";
+                }>;
+                detail: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>;
+            config: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean]>>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    add: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        kind: import("zod").ZodLiteral<"devops">;
+        config: import("zod").ZodObject<{}, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        kind: import("zod").ZodLiteral<"monorepo">;
+        config: import("zod").ZodObject<{}, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        kind: import("zod").ZodLiteral<"mcp">;
+        config: import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            token: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        kind: import("zod").ZodLiteral<"service">;
+        config: import("zod").ZodObject<{
+            service: import("zod").ZodEnum<{
+                signoz: "signoz";
+                outline: "outline";
+                paperless: "paperless";
+                openproject: "openproject";
+                invoiceninja: "invoiceninja";
+                infisical: "infisical";
+            }>;
+            domain: import("zod").ZodString;
+            on: import("zod").ZodString;
+            expose: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        kind: import("zod").ZodLiteral<"integration">;
+        config: import("zod").ZodObject<{
+            provider: import("zod").ZodLiteral<"stripe">;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        kind: import("zod").ZodLiteral<"cli">;
+        config: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            provider: import("zod").ZodLiteral<"discord">;
+            botToken: import("zod").ZodString;
+            voiceModel: import("zod").ZodOptional<import("zod").ZodEnum<{
+                small: "small";
+                base: "base";
+                tiny: "tiny";
+                medium: "medium";
+                "large-v3-turbo": "large-v3-turbo";
+            }>>;
+            voiceLanguage: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            provider: import("zod").ZodLiteral<"github">;
+            token: import("zod").ZodString;
+            git: import("zod").ZodOptional<import("zod").ZodEnum<{
+                on: "on";
+                off: "off";
+            }>>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            provider: import("zod").ZodLiteral<"gitlab">;
+            token: import("zod").ZodString;
+            url: import("zod").ZodString;
+            git: import("zod").ZodOptional<import("zod").ZodEnum<{
+                on: "on";
+                off: "off";
+            }>>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            provider: import("zod").ZodLiteral<"sentry">;
+            token: import("zod").ZodString;
+            url: import("zod").ZodString;
+            org: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            provider: import("zod").ZodLiteral<"redmine">;
+            url: import("zod").ZodString;
+            apiKey: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            provider: import("zod").ZodLiteral<"outline">;
+            url: import("zod").ZodString;
+            apiKey: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            provider: import("zod").ZodLiteral<"imap">;
+            host: import("zod").ZodString;
+            port: import("zod").ZodCoercedNumber<unknown>;
+            username: import("zod").ZodString;
+            password: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            provider: import("zod").ZodLiteral<"signoz">;
+            url: import("zod").ZodString;
+            apiKey: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            provider: import("zod").ZodLiteral<"postgres">;
+            host: import("zod").ZodString;
+            port: import("zod").ZodCoercedNumber<unknown>;
+            user: import("zod").ZodString;
+            password: import("zod").ZodString;
+            database: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            provider: import("zod").ZodLiteral<"mysql">;
+            host: import("zod").ZodString;
+            port: import("zod").ZodCoercedNumber<unknown>;
+            user: import("zod").ZodString;
+            password: import("zod").ZodString;
+            database: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>], "provider">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        kind: import("zod").ZodLiteral<"plugin">;
+        config: import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            ref: import("zod").ZodOptional<import("zod").ZodString>;
+            path: import("zod").ZodOptional<import("zod").ZodString>;
+            token: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        kind: import("zod").ZodLiteral<"ssh">;
+        config: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            auth: import("zod").ZodLiteral<"key">;
+            host: import("zod").ZodString;
+            port: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
+            user: import("zod").ZodString;
+            privateKey: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            auth: import("zod").ZodLiteral<"password">;
+            host: import("zod").ZodString;
+            port: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
+            user: import("zod").ZodString;
+            password: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>], "auth">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        kind: import("zod").ZodLiteral<"vpn">;
+        config: import("zod").ZodObject<{
+            config: import("zod").ZodString;
+            enabled: import("zod").ZodDefault<import("zod").ZodEnum<{
+                on: "on";
+                off: "off";
+            }>>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        kind: import("zod").ZodLiteral<"docker">;
+        config: import("zod").ZodObject<{
+            enabled: import("zod").ZodDefault<import("zod").ZodEnum<{
+                on: "on";
+                off: "off";
+            }>>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        kind: import("zod").ZodLiteral<"browser">;
+        config: import("zod").ZodObject<{
+            platform: import("zod").ZodEnum<{
+                reddit: "reddit";
+                x: "x";
+                youtube: "youtube";
+            }>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>], "kind">, import("@orpc/contract").Schema<AsyncIteratorObject<{
+        [x: string]: unknown;
+        kind: string;
+    }, unknown, void>, import("@orpc/contract").AsyncIteratorClass<{
+        [x: string]: unknown;
+        kind: string;
+    }, unknown, void>>, Record<never, never>, Record<never, never>>;
+    remove: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    setSecret: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        value: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    status: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        state: import("zod").ZodEnum<{
+            pending: "pending";
+            error: "error";
+            active: "active";
+            inactive: "inactive";
+        }>;
+        detail: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    marketplace: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        url: import("zod").ZodString;
+        token: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        plugins: import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            version: import("zod").ZodOptional<import("zod").ZodString>;
+            install: import("zod").ZodOptional<import("zod").ZodObject<{
+                url: import("zod").ZodString;
+                ref: import("zod").ZodOptional<import("zod").ZodString>;
+                path: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+};
+//# sourceMappingURL=capabilities.contract.d.ts.map

package/dist/contracts/capabilities.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/capabilities.contract.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQhC,CAAC"}

package/dist/contracts/capabilities.contract.js

@@ -0,0 +1,12 @@
+import { eventIterator, oc } from "@orpc/contract";
+import { IntenticLineSchema } from "../events.js";
+import { CapabilitiesListSchema, CapabilityIdParamSchema, CapabilitySchema, CapabilitySecretInputSchema, CapabilityStatusSchema, MarketplaceRequestSchema, MarketplaceSchema, OkSchema, } from "../schemas.js";
+export const capabilitiesContract = {
+    list: oc.route({ method: "GET", path: "/capabilities" }).output(CapabilitiesListSchema),
+    add: oc.route({ method: "POST", path: "/capabilities" }).input(CapabilitySchema).output(eventIterator(IntenticLineSchema)),
+    remove: oc.route({ method: "DELETE", path: "/capabilities/{id}" }).input(CapabilityIdParamSchema).output(OkSchema),
+    setSecret: oc.route({ method: "POST", path: "/capabilities/{id}/secret" }).input(CapabilitySecretInputSchema).output(OkSchema),
+    status: oc.route({ method: "GET", path: "/capabilities/{id}/status" }).input(CapabilityIdParamSchema).output(CapabilityStatusSchema),
+    marketplace: oc.route({ method: "POST", path: "/capabilities/marketplace" }).input(MarketplaceRequestSchema).output(MarketplaceSchema),
+};
+//# sourceMappingURL=capabilities.contract.js.map

package/dist/contracts/capabilities.contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.contract.js","sourceRoot":"","sources":["../../src/contracts/capabilities.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EACH,sBAAsB,EACtB,uBAAuB,EACvB,gBAAgB,EAChB,2BAA2B,EAC3B,sBAAsB,EACtB,wBAAwB,EACxB,iBAAiB,EACjB,QAAQ,GACX,MAAM,eAAe,CAAC;AAOvB,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAChC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC,MAAM,CAAC,sBAAsB,CAAC;IACvF,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC;IAC1H,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAC,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IAElH,SAAS,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,2BAA2B,EAAE,CAAC,CAAC,KAAK,CAAC,2BAA2B,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IAC9H,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,2BAA2B,EAAE,CAAC,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC,MAAM,CAAC,sBAAsB,CAAC;IACpI,WAAW,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,2BAA2B,EAAE,CAAC,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC,MAAM,CAAC,iBAAiB,CAAC;CACzI,CAAC"}

package/dist/contracts/claude.contract.js

@@ -1,9 +1,9 @@
 import { oc } from "@orpc/contract";
-import { AuthorizeChallengeSchema, ClaudeAccountSchema, ClaudeExchangeSchema, OkSchema } from "../schemas.js";
+import { AuthorizeChallengeSchema, OauthAccountSchema, OauthExchangeSchema, OkSchema } from "../schemas.js";
 export const claudeContract = {
     start: oc.route({ method: "POST", path: "/claude/oauth/start" }).output(AuthorizeChallengeSchema),
-    exchange: oc.route({ method: "POST", path: "/claude/oauth/exchange" }).input(ClaudeExchangeSchema).output(ClaudeAccountSchema),
-    account: oc.route({ method: "GET", path: "/claude/account" }).output(ClaudeAccountSchema),
+    exchange: oc.route({ method: "POST", path: "/claude/oauth/exchange" }).input(OauthExchangeSchema).output(OauthAccountSchema),
+    account: oc.route({ method: "GET", path: "/claude/account" }).output(OauthAccountSchema),
     disconnect: oc.route({ method: "POST", path: "/claude/account/disconnect" }).output(OkSchema),
 };
 //# sourceMappingURL=claude.contract.js.map

package/dist/contracts/claude.contract.js.map

@@ -1 +1 @@
-{"version":3,"file":"claude.contract.js","sourceRoot":"","sources":["../../src/contracts/claude.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAI9G,MAAM,CAAC,MAAM,cAAc,GAAG;IAC1B,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,qBAAqB,EAAE,CAAC,CAAC,MAAM,CAAC,wBAAwB,CAAC;IACjG,QAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,wBAAwB,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,MAAM,CAAC,mBAAmB,CAAC;IAC9H,OAAO,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAC,MAAM,CAAC,mBAAmB,CAAC;IACzF,UAAU,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,4BAA4B,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;CAChG,CAAC"}
+{"version":3,"file":"claude.contract.js","sourceRoot":"","sources":["../../src/contracts/claude.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAI5G,MAAM,CAAC,MAAM,cAAc,GAAG;IAC1B,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,qBAAqB,EAAE,CAAC,CAAC,MAAM,CAAC,wBAAwB,CAAC;IACjG,QAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,wBAAwB,EAAE,CAAC,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC,MAAM,CAAC,kBAAkB,CAAC;IAC5H,OAAO,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAC,MAAM,CAAC,kBAAkB,CAAC;IACxF,UAAU,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,4BAA4B,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;CAChG,CAAC"}