@intentic/sandbox-contract 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Artur Kurowski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,89 @@
+export declare const agentContract: {
+    run: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        prompt: import("zod").ZodString;
+        sessionId: import("zod").ZodOptional<import("zod").ZodString>;
+        model: import("zod").ZodOptional<import("zod").ZodString>;
+        plan: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        effort: import("zod").ZodOptional<import("zod").ZodString>;
+        thinking: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>, import("@orpc/contract").Schema<AsyncIteratorObject<{
+        kind: "session";
+        sessionId: string;
+    } | {
+        kind: "delta";
+        text: string;
+    } | {
+        kind: "tool";
+        name: string;
+        target?: string | undefined;
+    } | {
+        kind: "plan";
+        decisionId: string;
+        text: string;
+    } | {
+        kind: "question";
+        requestId: string;
+        questions: {
+            question: string;
+            header: string;
+            multiSelect: boolean;
+            options: {
+                label: string;
+                description: string;
+                preview?: string | undefined;
+            }[];
+        }[];
+    } | {
+        kind: "error";
+        message: string;
+    } | {
+        kind: "done";
+    }, unknown, void>, import("@orpc/contract").AsyncIteratorClass<{
+        kind: "session";
+        sessionId: string;
+    } | {
+        kind: "delta";
+        text: string;
+    } | {
+        kind: "tool";
+        name: string;
+        target?: string | undefined;
+    } | {
+        kind: "plan";
+        decisionId: string;
+        text: string;
+    } | {
+        kind: "question";
+        requestId: string;
+        questions: {
+            question: string;
+            header: string;
+            multiSelect: boolean;
+            options: {
+                label: string;
+                description: string;
+                preview?: string | undefined;
+            }[];
+        }[];
+    } | {
+        kind: "error";
+        message: string;
+    } | {
+        kind: "done";
+    }, unknown, void>>, Record<never, never>, Record<never, never>>;
+    decision: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        decisionId: import("zod").ZodString;
+        approve: import("zod").ZodBoolean;
+        feedback: import("zod").ZodOptional<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>>;
+    answer: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        requestId: import("zod").ZodString;
+        answers: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>>;
+        cancelled: import("zod").ZodOptional<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>>;
+};
+//# sourceMappingURL=agent.contract.d.ts.map

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

@@ -0,0 +1 @@
+{"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/agent.contract.js

@@ -0,0 +1,9 @@
+import { eventIterator, oc } from "@orpc/contract";
+import { AgentEventSchema } from "../events.js";
+import { AgentTurnSchema, AnswerSchema, DecisionSchema, OkSchema } from "../schemas.js";
+export const agentContract = {
+    run: oc.route({ method: "POST", path: "/agent" }).input(AgentTurnSchema).output(eventIterator(AgentEventSchema)),
+    decision: oc.route({ method: "POST", path: "/agent/decision" }).input(DecisionSchema).output(OkSchema),
+    answer: oc.route({ method: "POST", path: "/agent/answer" }).input(AnswerSchema).output(OkSchema),
+};
+//# sourceMappingURL=agent.contract.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"agent.contract.js","sourceRoot":"","sources":["../../src/contracts/agent.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAIxF,MAAM,CAAC,MAAM,aAAa,GAAG;IACzB,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC;IAChH,QAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IACtG,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;CACnG,CAAC"}

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

@@ -0,0 +1,23 @@
+export declare const claudeContract: {
+    start: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        authorizeUrl: import("zod").ZodString;
+        verifier: import("zod").ZodString;
+        state: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    exchange: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        code: import("zod").ZodString;
+        verifier: import("zod").ZodString;
+        state: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        connected: import("zod").ZodBoolean;
+        scope: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    account: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        connected: import("zod").ZodBoolean;
+        scope: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    disconnect: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+};
+//# sourceMappingURL=claude.contract.d.ts.map

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

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

package/dist/contracts/claude.contract.js

@@ -0,0 +1,9 @@
+import { oc } from "@orpc/contract";
+import { AuthorizeChallengeSchema, ClaudeAccountSchema, ClaudeExchangeSchema, 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),
+    disconnect: oc.route({ method: "POST", path: "/claude/account/disconnect" }).output(OkSchema),
+};
+//# sourceMappingURL=claude.contract.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,41 @@
+export declare const gitContract: {
+    status: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        repo: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        branch: import("zod").ZodString;
+        dirty: import("zod").ZodBoolean;
+        files: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    commit: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        repo: import("zod").ZodString;
+        message: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        committed: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    push: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        repo: import("zod").ZodString;
+        branch: 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>>;
+    files: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        repo: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        files: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    readFile: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        repo: import("zod").ZodString;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        path: import("zod").ZodString;
+        content: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    writeFile: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        repo: import("zod").ZodString;
+        path: import("zod").ZodString;
+        content: 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=git.contract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"git.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/git.contract.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOvB,CAAC"}

package/dist/contracts/git.contract.js

@@ -0,0 +1,11 @@
+import { oc } from "@orpc/contract";
+import { CommitResultSchema, CommitSchema, GitFileQuerySchema, GitFileSchema, GitFilesSchema, GitFileWriteSchema, GitStatusSchema, OkSchema, PushSchema, RepoParamSchema, } from "../schemas.js";
+export const gitContract = {
+    status: oc.route({ method: "GET", path: "/git/{repo}/status" }).input(RepoParamSchema).output(GitStatusSchema),
+    commit: oc.route({ method: "POST", path: "/git/{repo}/commit" }).input(CommitSchema).output(CommitResultSchema),
+    push: oc.route({ method: "POST", path: "/git/{repo}/push" }).input(PushSchema).output(OkSchema),
+    files: oc.route({ method: "GET", path: "/git/{repo}/files" }).input(RepoParamSchema).output(GitFilesSchema),
+    readFile: oc.route({ method: "GET", path: "/git/{repo}/file" }).input(GitFileQuerySchema).output(GitFileSchema),
+    writeFile: oc.route({ method: "PUT", path: "/git/{repo}/file" }).input(GitFileWriteSchema).output(OkSchema),
+};
+//# sourceMappingURL=git.contract.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"git.contract.js","sourceRoot":"","sources":["../../src/contracts/git.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EACH,kBAAkB,EAClB,YAAY,EACZ,kBAAkB,EAClB,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,eAAe,EACf,QAAQ,EACR,UAAU,EACV,eAAe,GAClB,MAAM,eAAe,CAAC;AAIvB,MAAM,CAAC,MAAM,WAAW,GAAG;IACvB,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC;IAC9G,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,kBAAkB,CAAC;IAC/G,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IAC/F,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC;IAC3G,QAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC;IAC/G,SAAS,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;CAC9G,CAAC"}

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

@@ -0,0 +1,12 @@
+export declare const intenticContract: {
+    run: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        args: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, 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>>;
+};
+//# sourceMappingURL=intentic.contract.d.ts.map

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

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

package/dist/contracts/intentic.contract.js

@@ -0,0 +1,7 @@
+import { eventIterator, oc } from "@orpc/contract";
+import { IntenticLineSchema } from "../events.js";
+import { IntenticRunSchema } from "../schemas.js";
+export const intenticContract = {
+    run: oc.route({ method: "POST", path: "/intentic" }).input(IntenticRunSchema).output(eventIterator(IntenticLineSchema)),
+};
+//# sourceMappingURL=intentic.contract.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intentic.contract.js","sourceRoot":"","sources":["../../src/contracts/intentic.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAIlD,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC5B,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC;CAC1H,CAAC"}

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

@@ -0,0 +1,93 @@
+export declare const inventoryContract: {
+    list: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        entries: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"backend">;
+            provider: import("zod").ZodEnum<{
+                host: "host";
+                cloudflare: "cloudflare";
+                github: "github";
+                stripe: "stripe";
+            }>;
+            name: import("zod").ZodString;
+            values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"service">;
+            service: import("zod").ZodEnum<{
+                signoz: "signoz";
+            }>;
+            name: import("zod").ZodString;
+            values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+            on: import("zod").ZodString;
+            expose: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>], "kind">>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    add: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"backend">;
+        provider: import("zod").ZodEnum<{
+            host: "host";
+            cloudflare: "cloudflare";
+            github: "github";
+            stripe: "stripe";
+        }>;
+        values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"service">;
+        service: import("zod").ZodEnum<{
+            signoz: "signoz";
+        }>;
+        values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+        on: import("zod").ZodString;
+        expose: import("zod").ZodString;
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>], "kind">, import("zod").ZodObject<{
+        entries: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"backend">;
+            provider: import("zod").ZodEnum<{
+                host: "host";
+                cloudflare: "cloudflare";
+                github: "github";
+                stripe: "stripe";
+            }>;
+            name: import("zod").ZodString;
+            values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"service">;
+            service: import("zod").ZodEnum<{
+                signoz: "signoz";
+            }>;
+            name: import("zod").ZodString;
+            values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+            on: import("zod").ZodString;
+            expose: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>], "kind">>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    remove: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        entries: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"backend">;
+            provider: import("zod").ZodEnum<{
+                host: "host";
+                cloudflare: "cloudflare";
+                github: "github";
+                stripe: "stripe";
+            }>;
+            name: import("zod").ZodString;
+            values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"service">;
+            service: import("zod").ZodEnum<{
+                signoz: "signoz";
+            }>;
+            name: import("zod").ZodString;
+            values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+            on: import("zod").ZodString;
+            expose: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>], "kind">>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    selfHost: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+};
+//# sourceMappingURL=inventory.contract.d.ts.map

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

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

package/dist/contracts/inventory.contract.js

@@ -0,0 +1,9 @@
+import { oc } from "@orpc/contract";
+import { AddInventoryInputSchema, InventoryListSchema, InventoryNameParamSchema, OkSchema } from "../schemas.js";
+export const inventoryContract = {
+    list: oc.route({ method: "GET", path: "/inventory" }).output(InventoryListSchema),
+    add: oc.route({ method: "POST", path: "/inventory" }).input(AddInventoryInputSchema).output(InventoryListSchema),
+    remove: oc.route({ method: "DELETE", path: "/inventory/{name}" }).input(InventoryNameParamSchema).output(InventoryListSchema),
+    selfHost: oc.route({ method: "POST", path: "/inventory/self-host" }).output(OkSchema),
+};
+//# sourceMappingURL=inventory.contract.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inventory.contract.js","sourceRoot":"","sources":["../../src/contracts/inventory.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAKjH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC7B,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC,MAAM,CAAC,mBAAmB,CAAC;IACjF,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC,MAAM,CAAC,mBAAmB,CAAC;IAChH,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC,MAAM,CAAC,mBAAmB,CAAC;IAC7H,QAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,sBAAsB,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;CACxF,CAAC"}

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

@@ -0,0 +1,21 @@
+export declare const sessionsContract: {
+    list: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        sessions: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            title: import("zod").ZodString;
+            updatedAt: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    get: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        messages: import("zod").ZodArray<import("zod").ZodObject<{
+            role: import("zod").ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+            }>;
+            text: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+};
+//# sourceMappingURL=sessions.contract.d.ts.map

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

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

package/dist/contracts/sessions.contract.js

@@ -0,0 +1,7 @@
+import { oc } from "@orpc/contract";
+import { SessionIdParamSchema, SessionsListSchema, SessionTranscriptSchema } from "../schemas.js";
+export const sessionsContract = {
+    list: oc.route({ method: "GET", path: "/sessions" }).output(SessionsListSchema),
+    get: oc.route({ method: "GET", path: "/sessions/{id}" }).input(SessionIdParamSchema).output(SessionTranscriptSchema),
+};
+//# sourceMappingURL=sessions.contract.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sessions.contract.js","sourceRoot":"","sources":["../../src/contracts/sessions.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAIlG,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC5B,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,kBAAkB,CAAC;IAC/E,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,MAAM,CAAC,uBAAuB,CAAC;CACvH,CAAC"}

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

@@ -0,0 +1,28 @@
+export declare const systemContract: {
+    preview: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        running: import("zod").ZodBoolean;
+        healthy: import("zod").ZodBoolean;
+        port: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    selfHost: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        selfHost: import("zod").ZodNullable<import("zod").ZodObject<{
+            user: import("zod").ZodString;
+            address: import("zod").ZodString;
+            port: import("zod").ZodNumber;
+            via: import("zod").ZodEnum<{
+                direct: "direct";
+                cloudflared: "cloudflared";
+            }>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    info: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        image: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    events: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").Schema<AsyncIteratorObject<{
+        kind: "heartbeat";
+    }, unknown, void>, import("@orpc/contract").AsyncIteratorClass<{
+        kind: "heartbeat";
+    }, unknown, void>>, Record<never, never>, Record<never, never>>;
+};
+//# sourceMappingURL=system.contract.d.ts.map

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

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

package/dist/contracts/system.contract.js

@@ -0,0 +1,10 @@
+import { eventIterator, oc } from "@orpc/contract";
+import { HeartbeatSchema } from "../events.js";
+import { InfoSchema, PreviewSchema, SelfHostResponseSchema } from "../schemas.js";
+export const systemContract = {
+    preview: oc.route({ method: "GET", path: "/preview" }).output(PreviewSchema),
+    selfHost: oc.route({ method: "GET", path: "/self-host" }).output(SelfHostResponseSchema),
+    info: oc.route({ method: "GET", path: "/info" }).output(InfoSchema),
+    events: oc.route({ method: "GET", path: "/events" }).output(eventIterator(HeartbeatSchema)),
+};
+//# sourceMappingURL=system.contract.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"system.contract.js","sourceRoot":"","sources":["../../src/contracts/system.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAIlF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC1B,OAAO,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC;IAC5E,QAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC,MAAM,CAAC,sBAAsB,CAAC;IACxF,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC;IACnE,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC;CAC9F,CAAC"}

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

@@ -0,0 +1,53 @@
+export declare const workspaceContract: {
+    tree: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        root: import("zod").ZodString;
+        tree: import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            path: import("zod").ZodString;
+            type: import("zod").ZodEnum<{
+                file: "file";
+                dir: "dir";
+            }>;
+            size: import("zod").ZodOptional<import("zod").ZodNumber>;
+            children: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<any, import("zod/v4/core").$strip>>>;
+        }, import("zod/v4/core").$strip>>;
+        truncated: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    file: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        path: import("zod").ZodString;
+        content: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    repos: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        repos: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    addRepo: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        cloneUrl: import("zod").ZodString;
+        branch: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    tools: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        tools: import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            url: import("zod").ZodString;
+            hasToken: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    addTool: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        url: import("zod").ZodString;
+        token: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    removeTool: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        name: 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=workspace.contract.d.ts.map

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

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

package/dist/contracts/workspace.contract.js

@@ -0,0 +1,12 @@
+import { oc } from "@orpc/contract";
+import { CloneRepoSchema, CloneResultSchema, OkSchema, ReposListSchema, ToolAddResultSchema, ToolInputSchema, ToolNameParamSchema, ToolsListSchema, WorkspaceFileQuerySchema, WorkspaceFileSchema, WorkspaceTreeSchema, } from "../schemas.js";
+export const workspaceContract = {
+    tree: oc.route({ method: "GET", path: "/workspace/tree" }).output(WorkspaceTreeSchema),
+    file: oc.route({ method: "GET", path: "/workspace/file" }).input(WorkspaceFileQuerySchema).output(WorkspaceFileSchema),
+    repos: oc.route({ method: "GET", path: "/workspace/repos" }).output(ReposListSchema),
+    addRepo: oc.route({ method: "POST", path: "/workspace/repos" }).input(CloneRepoSchema).output(CloneResultSchema),
+    tools: oc.route({ method: "GET", path: "/workspace/tools" }).output(ToolsListSchema),
+    addTool: oc.route({ method: "POST", path: "/workspace/tools" }).input(ToolInputSchema).output(ToolAddResultSchema),
+    removeTool: oc.route({ method: "DELETE", path: "/workspace/tools/{name}" }).input(ToolNameParamSchema).output(OkSchema),
+};
+//# sourceMappingURL=workspace.contract.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.contract.js","sourceRoot":"","sources":["../../src/contracts/workspace.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EACH,eAAe,EACf,iBAAiB,EACjB,QAAQ,EACR,eAAe,EACf,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,eAAe,EACf,wBAAwB,EACxB,mBAAmB,EACnB,mBAAmB,GACtB,MAAM,eAAe,CAAC;AAKvB,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC7B,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAC,MAAM,CAAC,mBAAmB,CAAC;IACtF,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC,MAAM,CAAC,mBAAmB,CAAC;IACtH,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC;IACpF,OAAO,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,MAAM,CAAC,iBAAiB,CAAC;IAChH,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC;IACpF,OAAO,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,MAAM,CAAC,mBAAmB,CAAC;IAClH,UAAU,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,yBAAyB,EAAE,CAAC,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;CAC1H,CAAC"}

package/dist/events.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+export declare const AskOptionSchema: z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodString;
+    preview: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AskOption = z.infer<typeof AskOptionSchema>;
+export declare const AskQuestionSchema: z.ZodObject<{
+    question: z.ZodString;
+    header: z.ZodString;
+    multiSelect: z.ZodBoolean;
+    options: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodString;
+        preview: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AskQuestion = z.infer<typeof AskQuestionSchema>;
+export declare const AgentEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"session">;
+    sessionId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"delta">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"tool">;
+    name: z.ZodString;
+    target: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"plan">;
+    decisionId: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"question">;
+    requestId: z.ZodString;
+    questions: z.ZodArray<z.ZodObject<{
+        question: z.ZodString;
+        header: z.ZodString;
+        multiSelect: z.ZodBoolean;
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodString;
+            preview: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"error">;
+    message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"done">;
+}, z.core.$strip>], "kind">;
+export type AgentEvent = z.infer<typeof AgentEventSchema>;
+export declare const IntenticLineSchema: z.ZodObject<{
+    kind: z.ZodString;
+}, z.core.$loose>;
+export type IntenticLine = z.infer<typeof IntenticLineSchema>;
+export declare const HeartbeatSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"heartbeat">;
+}, z.core.$strip>;
+export type Heartbeat = z.infer<typeof HeartbeatSchema>;
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,eAAe;;;;iBAI1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,iBAAiB;;;;;;;;;iBAK5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAK5D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAQ3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAK1D,eAAO,MAAM,kBAAkB;;iBAAsC,CAAC;AACtE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAI9D,eAAO,MAAM,eAAe;;iBAA6C,CAAC;AAC1E,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}