@fungi.computer/knapsack 0.1.0 → 0.2.1

package/dist/ui/wire.d.ts

@@ -0,0 +1,290 @@
+import * as z from "zod";
+export declare const uiWireIds: Readonly<{
+    readonly request: import("@fungi.computer/cairn").IdCodec<"knapsack-ui", "request", 1>;
+    readonly connection: import("@fungi.computer/cairn").IdCodec<"knapsack-ui", "connection", 1>;
+    readonly claim: import("@fungi.computer/cairn").IdCodec<"knapsack-ui", "claim", 1>;
+    readonly attempt: import("@fungi.computer/cairn").IdCodec<"knapsack-ui", "attempt", 1>;
+}>;
+export declare const BrowserWireObjectSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type BrowserWireObject = z.output<typeof BrowserWireObjectSchema>;
+export declare const BrowserCommandRowSchema: z.ZodUnion<readonly [z.ZodObject<{
+    action: z.ZodUnion<readonly [z.ZodObject<{
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        outputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strict>, z.ZodObject<{
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strict>, z.ZodObject<{
+        outputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strict>]>;
+    commandId: z.ZodString;
+    sourceId: z.ZodString;
+    title: z.ZodString;
+    category: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    order: z.ZodNumber;
+    keybind: z.ZodNullable<z.ZodString>;
+    availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodString;
+    }, z.core.$strip>], "status">;
+}, z.core.$strict>, z.ZodObject<{
+    commandId: z.ZodString;
+    sourceId: z.ZodString;
+    title: z.ZodString;
+    category: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    order: z.ZodNumber;
+    keybind: z.ZodNullable<z.ZodString>;
+    availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodString;
+    }, z.core.$strip>], "status">;
+}, z.core.$strict>]>;
+export declare const BrowserExecuteInputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    commandId: z.ZodString;
+    arguments: z.ZodJSONSchema;
+}, z.core.$strict>, z.ZodObject<{
+    commandId: z.ZodString;
+}, z.core.$strict>]>;
+declare const BrowserRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"discover">;
+}, z.core.$strict>, z.ZodObject<{
+    commandId: z.ZodString;
+    arguments: z.ZodJSONSchema;
+    type: z.ZodLiteral<"execute">;
+}, z.core.$strict>, z.ZodObject<{
+    commandId: z.ZodString;
+    type: z.ZodLiteral<"execute">;
+}, z.core.$strict>]>;
+declare const BrowserRequestEnvelopeSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    request: z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"discover">;
+    }, z.core.$strict>, z.ZodObject<{
+        commandId: z.ZodString;
+        arguments: z.ZodJSONSchema;
+        type: z.ZodLiteral<"execute">;
+    }, z.core.$strict>, z.ZodObject<{
+        commandId: z.ZodString;
+        type: z.ZodLiteral<"execute">;
+    }, z.core.$strict>]>;
+}, z.core.$strip>;
+export declare const BrowserRequestDeliverySchema: z.ZodObject<{
+    requestId: z.ZodString;
+    request: z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"discover">;
+    }, z.core.$strict>, z.ZodObject<{
+        commandId: z.ZodString;
+        arguments: z.ZodJSONSchema;
+        type: z.ZodLiteral<"execute">;
+    }, z.core.$strict>, z.ZodObject<{
+        commandId: z.ZodString;
+        type: z.ZodLiteral<"execute">;
+    }, z.core.$strict>]>;
+    connectionId: z.ZodString;
+}, z.core.$strip>;
+export declare const BrowserClaimSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    connectionId: z.ZodString;
+    attemptId: z.ZodString;
+}, z.core.$strip>;
+export declare const BrowserClaimResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"claimed">;
+    claimId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"waiting">;
+    retryAfterMs: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"skipped">;
+}, z.core.$strip>], "status">;
+export declare const BrowserExecutionOutcomeSchema: z.ZodUnion<readonly [z.ZodObject<{
+    status: z.ZodLiteral<"handled">;
+    result: z.ZodJSONSchema;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"handled">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"closed">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"missing">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"invalid">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"unavailable">;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"failed">;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodJSONSchema;
+    }, z.core.$strip>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"failed">;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+declare const BrowserWireResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"discover">;
+    commands: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        action: z.ZodUnion<readonly [z.ZodObject<{
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            outputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>, z.ZodObject<{
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>, z.ZodObject<{
+            outputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>]>;
+        commandId: z.ZodString;
+        sourceId: z.ZodString;
+        title: z.ZodString;
+        category: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        order: z.ZodNumber;
+        keybind: z.ZodNullable<z.ZodString>;
+        availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodString;
+        }, z.core.$strip>], "status">;
+    }, z.core.$strict>, z.ZodObject<{
+        commandId: z.ZodString;
+        sourceId: z.ZodString;
+        title: z.ZodString;
+        category: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        order: z.ZodNumber;
+        keybind: z.ZodNullable<z.ZodString>;
+        availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodString;
+        }, z.core.$strip>], "status">;
+    }, z.core.$strict>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"execute">;
+    outcome: z.ZodUnion<readonly [z.ZodObject<{
+        status: z.ZodLiteral<"handled">;
+        result: z.ZodJSONSchema;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"handled">;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"closed">;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"missing">;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"invalid">;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"failed">;
+        error: z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            details: z.ZodJSONSchema;
+        }, z.core.$strip>;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"failed">;
+        error: z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>]>;
+}, z.core.$strip>], "type">;
+export declare const BrowserResultEnvelopeSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    claimId: z.ZodString;
+    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"discover">;
+        commands: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            action: z.ZodUnion<readonly [z.ZodObject<{
+                inputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+                outputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strict>, z.ZodObject<{
+                inputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strict>, z.ZodObject<{
+                outputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strict>]>;
+            commandId: z.ZodString;
+            sourceId: z.ZodString;
+            title: z.ZodString;
+            category: z.ZodString;
+            description: z.ZodNullable<z.ZodString>;
+            order: z.ZodNumber;
+            keybind: z.ZodNullable<z.ZodString>;
+            availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<"unavailable">;
+                reason: z.ZodString;
+            }, z.core.$strip>], "status">;
+        }, z.core.$strict>, z.ZodObject<{
+            commandId: z.ZodString;
+            sourceId: z.ZodString;
+            title: z.ZodString;
+            category: z.ZodString;
+            description: z.ZodNullable<z.ZodString>;
+            order: z.ZodNumber;
+            keybind: z.ZodNullable<z.ZodString>;
+            availability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<"unavailable">;
+                reason: z.ZodString;
+            }, z.core.$strip>], "status">;
+        }, z.core.$strict>]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"execute">;
+        outcome: z.ZodUnion<readonly [z.ZodObject<{
+            status: z.ZodLiteral<"handled">;
+            result: z.ZodJSONSchema;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"handled">;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"closed">;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"missing">;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"invalid">;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"failed">;
+            error: z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                details: z.ZodJSONSchema;
+            }, z.core.$strip>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"failed">;
+            error: z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>;
+export declare const BrowserSettlementResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"accepted">;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"ignored">;
+}, z.core.$strip>], "status">;
+export type BrowserCommandRow = z.output<typeof BrowserCommandRowSchema>;
+export type BrowserRequest = z.output<typeof BrowserRequestSchema>;
+export type BrowserRequestEnvelope = z.output<typeof BrowserRequestEnvelopeSchema>;
+export type BrowserRequestDelivery = z.output<typeof BrowserRequestDeliverySchema>;
+export type BrowserClaim = z.output<typeof BrowserClaimSchema>;
+export type BrowserClaimResult = z.output<typeof BrowserClaimResultSchema>;
+export type BrowserWireResult = z.output<typeof BrowserWireResultSchema>;
+export type BrowserResultEnvelope = z.output<typeof BrowserResultEnvelopeSchema>;
+export type BrowserSettlementResult = z.output<typeof BrowserSettlementResultSchema>;
+export {};

package/dist/ui/wire.js

@@ -0,0 +1,136 @@
+import { defineIdFamily } from "@fungi.computer/cairn";
+import * as z from "zod";
+export const uiWireIds = defineIdFamily({
+    family: "knapsack-ui",
+    version: 1,
+    kinds: {
+        request: { prefix: "ui_request" },
+        connection: { prefix: "ui_connection" },
+        claim: { prefix: "ui_claim" },
+        attempt: { prefix: "ui_attempt" },
+    },
+});
+const identifier = z.string().min(1).max(256);
+const requestId = z
+    .string()
+    .refine((value) => uiWireIds.request.parse(value).ok);
+const json = z.json();
+const schemaDocument = z.record(z.string(), json);
+export const BrowserWireObjectSchema = z.record(z.string(), z.unknown());
+const WhistleAvailabilitySchema = z.discriminatedUnion("status", [
+    z.object({ status: z.literal("available") }),
+    z.object({ status: z.literal("unavailable"), reason: z.string() }),
+]);
+/** The same descriptor is decoded at browser ingress and in model tool results. */
+const browserCommandRowFields = {
+    commandId: identifier,
+    sourceId: identifier,
+    title: z.string(),
+    category: z.string(),
+    description: z.string().nullable(),
+    order: z.number(),
+    keybind: z.string().nullable(),
+    availability: WhistleAvailabilitySchema,
+};
+const browserActionSchema = z.union([
+    z
+        .object({ inputSchema: schemaDocument, outputSchema: schemaDocument })
+        .strict(),
+    z.object({ inputSchema: schemaDocument }).strict(),
+    z.object({ outputSchema: schemaDocument }).strict(),
+]);
+const browserCommandRowWithActionSchema = z
+    .object({ ...browserCommandRowFields, action: browserActionSchema })
+    .strict();
+const browserCommandRowWithoutActionSchema = z
+    .object(browserCommandRowFields)
+    .strict();
+export const BrowserCommandRowSchema = z.union([
+    browserCommandRowWithActionSchema,
+    browserCommandRowWithoutActionSchema,
+]);
+const browserExecuteCommandSchema = z.object({
+    commandId: z.string().max(256),
+});
+const browserExecuteInputWireSchema = browserExecuteCommandSchema
+    .extend({ arguments: json })
+    .strict();
+const browserExecuteInputWithoutArgumentsSchema = browserExecuteCommandSchema.strict();
+export const BrowserExecuteInputSchema = z.union([
+    browserExecuteInputWireSchema,
+    browserExecuteInputWithoutArgumentsSchema,
+]);
+const BrowserRequestSchema = z.union([
+    z.object({ type: z.literal("discover") }).strict(),
+    browserExecuteInputWireSchema.extend({ type: z.literal("execute") }),
+    browserExecuteInputWithoutArgumentsSchema.extend({
+        type: z.literal("execute"),
+    }),
+]);
+const BrowserRequestEnvelopeSchema = z.object({
+    requestId,
+    request: BrowserRequestSchema,
+});
+export const BrowserRequestDeliverySchema = BrowserRequestEnvelopeSchema.extend({
+    connectionId: z
+        .string()
+        .refine((value) => uiWireIds.connection.parse(value).ok),
+});
+export const BrowserClaimSchema = z.object({
+    requestId,
+    connectionId: z
+        .string()
+        .refine((value) => uiWireIds.connection.parse(value).ok),
+    attemptId: z.string().refine((value) => uiWireIds.attempt.parse(value).ok),
+});
+export const BrowserClaimResultSchema = z.discriminatedUnion("status", [
+    z.object({ status: z.literal("claimed"), claimId: z.string() }),
+    z.object({
+        status: z.literal("waiting"),
+        retryAfterMs: z.number().int().min(10).max(1_000),
+    }),
+    z.object({ status: z.literal("skipped") }),
+]);
+export const BrowserExecutionOutcomeSchema = z.union([
+    z.object({ status: z.literal("handled"), result: json }).strict(),
+    z.object({ status: z.literal("handled") }).strict(),
+    z.object({ status: z.literal("closed") }).strict(),
+    z.object({ status: z.literal("missing") }).strict(),
+    z.object({ status: z.literal("invalid") }).strict(),
+    z.object({ status: z.literal("unavailable"), reason: z.string() }).strict(),
+    z
+        .object({
+        status: z.literal("failed"),
+        error: z.object({
+            code: z.string(),
+            message: z.string(),
+            details: json,
+        }),
+    })
+        .strict(),
+    z
+        .object({
+        status: z.literal("failed"),
+        error: z.object({ code: z.string(), message: z.string() }).strict(),
+    })
+        .strict(),
+]);
+const BrowserWireResultSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("discover"),
+        commands: z.array(BrowserCommandRowSchema),
+    }),
+    z.object({
+        type: z.literal("execute"),
+        outcome: BrowserExecutionOutcomeSchema,
+    }),
+]);
+export const BrowserResultEnvelopeSchema = z.object({
+    requestId,
+    claimId: z.string().refine((value) => uiWireIds.claim.parse(value).ok),
+    result: BrowserWireResultSchema,
+});
+export const BrowserSettlementResultSchema = z.discriminatedUnion("status", [
+    z.object({ status: z.literal("accepted") }),
+    z.object({ status: z.literal("ignored") }),
+]);

package/dist/ui-browser.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Browser side of Knapsack.ui: connect the App's Whistle runtime to one Agent
+ * Session's `/browser/*` transport so the Agent can discover and run its
+ * live commands.
+ */
+export { connectBrowser, UiBrowserError, type BrowserConnection, type BrowserConnectionOptions, } from "./ui/browser.js";

package/dist/ui-browser.js

@@ -0,0 +1,6 @@
+/**
+ * Browser side of Knapsack.ui: connect the App's Whistle runtime to one Agent
+ * Session's `/browser/*` transport so the Agent can discover and run its
+ * live commands.
+ */
+export { connectBrowser, UiBrowserError, } from "./ui/browser.js";

package/dist/ui.d.ts

@@ -0,0 +1,29 @@
+import type { CapabilitySource } from "@fungi.computer/mycelium";
+/** How one Agent host connects its Sessions' open Apps to Knapsack.ui. */
+export type UiConnectionOptions = Readonly<{
+    /** Stable, secret-free capability source id, such as `"hub-ui"`. */
+    id: string;
+    /** Whether the Session is stored; only a stored Session's browser may connect. */
+    hasSession: (sessionId: string) => Promise<boolean>;
+}>;
+/**
+ * Live commands of the App open in each Agent Session's browser. The Agent
+ * reaches them through the `ui` module (`ui.discover`, `ui.execute`); the
+ * browser runs them through Whistle over the transport this connection serves.
+ */
+export type UiConnection = Readonly<{
+    /**
+     * Each Session run borrows its Session's `ui` module and releases it when
+     * the run ends. A Session-free acquisition contributes no module.
+     */
+    source: CapabilitySource;
+    /**
+     * Serve `/browser/sessions/<sessionId>/browser/{events,claims,results}`.
+     * It authenticates nobody: mount it behind the host's own authorization.
+     */
+    fetch: (request: Request) => Promise<Response>;
+    /** End every browser stream; later requests answer 410 and later borrows fail. */
+    close: () => Promise<void>;
+}>;
+/** Connect the open App's live Whistle commands to each Agent Session. */
+export declare function ui(options: UiConnectionOptions): UiConnection;

package/dist/ui.js

@@ -0,0 +1,35 @@
+import { createUiHost } from "./ui/host.js";
+import { BrowserSessions } from "./ui/sessions.js";
+/** Borrow one Session's `ui` module for the acquiring run. */
+function borrow(sessions, context) {
+    context.signal.throwIfAborted();
+    if (context.session === undefined)
+        return {
+            snapshot: { version: "no-session", modules: [] },
+            release: () => Promise.resolve(),
+        };
+    const sessionId = context.session.sessionId;
+    const lease = sessions.acquire(sessionId);
+    return {
+        snapshot: { version: `session:${sessionId}`, modules: lease.modules },
+        release: () => {
+            lease.release();
+            return Promise.resolve();
+        },
+    };
+}
+/** Connect the open App's live Whistle commands to each Agent Session. */
+export function ui(options) {
+    const sessions = new BrowserSessions(() => createUiHost(), options.hasSession);
+    return Object.freeze({
+        source: {
+            id: options.id,
+            // The executor turns a refused borrow (aborted, or closed) into a rejection.
+            acquire: (context) => new Promise((resolve) => {
+                resolve(borrow(sessions, context));
+            }),
+        },
+        fetch: (request) => sessions.fetch(request),
+        close: () => sessions.close(),
+    });
+}

package/docs/api/README.md

@@ -15,3 +15,4 @@
 | [files-read](files-read.md)             | -           |
 | [index](index.md)                       | -           |
 | [patch](patch.md)                       | -           |
+| [ui-browser](ui-browser.md)             | -           |

package/docs/api/files-patch.md

@@ -13,11 +13,13 @@
 ### patchInputSchema
 
 ```ts
-const patchInputSchema: ZodObject<
-  {
-    patch: ZodString;
-  },
-  $strict
+const patchInputSchema: ZodLazy<
+  ZodObject<
+    {
+      patch: ZodString;
+    },
+    $strict
+  >
 >;
 ```
 
@@ -28,44 +30,38 @@ Browser-safe patch contracts shared by native Files tools and Computer HTTP.
 ### patchOutputSchema
 
 ```ts
-const patchOutputSchema: ZodUnion<
-  readonly [
-    ZodObject<
-      {
-        status: ZodEnum<{
-          completed: "completed";
-          failed: "failed";
-          cancelled: "cancelled";
-        }>;
-        exitCode: ZodNumber;
-        stdout: ZodString;
-        stderr: ZodString;
-        truncated: ZodBoolean;
-      },
-      $strict
-    >,
-    ZodObject<
-      {
-        status: ZodEnum<{
-          completed: "completed";
-          failed: "failed";
-          cancelled: "cancelled";
-        }>;
-        exitCode: ZodNumber;
-        stdout: ZodString;
-        stderr: ZodString;
-        truncated: ZodBoolean;
-        error: ZodObject<
-          {
-            kind: ZodLiteral<"mismatch">;
-          },
-          $strict
-        >;
-      },
-      $strict
-    >,
-  ]
->;
+const patchOutputSchema: ZodLazy<ZodUnion<readonly [ZodObject<{
+  status: ZodEnum<{
+     completed: "completed";
+     failed: "failed";
+     cancelled: "cancelled";
+  }>;
+  exitCode: ZodNumber;
+  stdout: ZodString;
+  stderr: ZodString;
+  truncated: ZodUnion<readonly [ZodLiteral<false>, ZodArray<ZodObject<{
+     stream: ZodEnum<...>;
+     keptBytes: ZodNumber;
+     totalBytes: ZodNumber;
+  }, $strict>>]>;
+}, $strict>, ZodObject<{
+  status: ZodEnum<{
+     completed: "completed";
+     failed: "failed";
+     cancelled: "cancelled";
+  }>;
+  exitCode: ZodNumber;
+  stdout: ZodString;
+  stderr: ZodString;
+  truncated: ZodUnion<readonly [ZodLiteral<false>, ZodArray<ZodObject<{
+     stream: ZodEnum<...>;
+     keptBytes: ZodNumber;
+     totalBytes: ZodNumber;
+  }, $strict>>]>;
+  error: ZodObject<{
+     kind: ZodLiteral<"mismatch">;
+  }, $strict>;
+}, $strict>]>>;
 ```
 
 Native patch completion, cancellation or failure, including an optional