stitchkit 0.110.0 → 0.110.2

package/CHANGELOG.md

@@ -15,6 +15,23 @@ additive**; the first breaking change landed in 0.10.0. Grep the file for
 
 ## [Unreleased]
 
+## [0.110.2] - 2026-10-15
+
+### Added
+
+- `stitchkit/agent-runtime`: atomic `store.branchConversation()` creates an independent conversation from an exact settled prefix or a validated archive. Typed identities and spill references are rekeyed; stable retries return a durable lineage receipt, while control observations remain inert and artifact access requires fresh destination policy. Six input/result/receipt type and schema exports belong to this entrypoint (I3, I8, I12, I15). Unknown opaque payloads fail before any destination write. Abandon transitions retain their exact terminal assistant for reconstruction after compaction; incomplete legacy recovery archives refuse.
+
+## [0.110.1] - 2026-10-14
+
+### Added
+
+- `stitchkit/realtime` provides the shared typed Socket.IO client and retained-topic helpers through an explicit-peer graph that Hermes can compile. Pass `peers: { client: () => import('socket.io-client') }`; root Node/Web clients keep optional lazy peer resolution. HTTP uploads are also available from `stitchkit/http`, so native/shared modules can use public leaves throughout their graph (I7, I8).
+
+### Fixed
+
+- Process-group cleanup accepts a fresh kernel absence after SIGKILL instead of relying only on a potentially stale process-table snapshot. Permission refusals and unknown/exiting states still require proof; the same cleanup deadline applies and failures retain their last observed states.
+- A synchronously throwing injected Socket.IO peer loader now reaches `onConnectError`, clears connection intent and allows the next `connect()` to retry, just like an asynchronously rejected loader.
+
 ## [0.110.0] - 2026-10-14
 
 ### ⚠️ Breaking changes

package/dist/agent-runtime/archive-spill.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+export declare const ArchiveSpillSchema: z.ZodObject<{
+    reference: z.ZodString;
+    runId: z.ZodOptional<z.ZodString>;
+    toolCallId: z.ZodOptional<z.ZodString>;
+    mediaType: z.ZodString;
+    bytes: z.ZodInt;
+    sha256: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    expiresAt: z.ZodOptional<z.ZodISODateTime>;
+    authorization: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        operation: z.ZodLiteral<"read">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"write">;
+        path: z.ZodString;
+        bytes: z.ZodInt;
+        overwrite: z.ZodBoolean;
+        createsDirectories: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"search">;
+        query: z.ZodString;
+        mode: z.ZodEnum<{
+            content: "content";
+            path: "path";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"edit">;
+        path: z.ZodString;
+        baseSha256: z.ZodString;
+        resultSha256: z.ZodString;
+        resultBytes: z.ZodInt;
+        replacements: z.ZodInt;
+        dryRun: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"list">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"glob">;
+        pattern: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"artifact-read">;
+        reference: z.ZodString;
+        offset: z.ZodInt;
+        maxBytes: z.ZodInt;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"artifact-search">;
+        reference: z.ZodString;
+        query: z.ZodString;
+        maxMatches: z.ZodInt;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"shell">;
+        executable: z.ZodString;
+        args: z.ZodArray<z.ZodString>;
+        cwd: z.ZodString;
+    }, z.core.$strict>], "operation">>;
+    base64: z.ZodString;
+}, z.core.$strict>;
+export type ArchiveSpill = z.infer<typeof ArchiveSpillSchema>;
+//# sourceMappingURL=archive-spill.d.ts.map

package/dist/agent-runtime/archive-spill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-spill.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/archive-spill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0B3B,CAAC;AAEL,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/agent-runtime/branch-contract.d.ts

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+export declare const BranchAgentConversationInputSchema: z.ZodObject<{
+    requestKey: z.ZodString;
+    destinationConversationId: z.ZodString;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"conversation">;
+        conversationId: z.ZodString;
+        throughRunId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"archive">;
+        bytes: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+    }, z.core.$strict>], "kind">;
+    artifactAuthorization: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        operation: z.ZodLiteral<"read">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"write">;
+        path: z.ZodString;
+        bytes: z.ZodInt;
+        overwrite: z.ZodBoolean;
+        createsDirectories: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"search">;
+        query: z.ZodString;
+        mode: z.ZodEnum<{
+            content: "content";
+            path: "path";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"edit">;
+        path: z.ZodString;
+        baseSha256: z.ZodString;
+        resultSha256: z.ZodString;
+        resultBytes: z.ZodInt;
+        replacements: z.ZodInt;
+        dryRun: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"list">;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"glob">;
+        pattern: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"artifact-read">;
+        reference: z.ZodString;
+        offset: z.ZodInt;
+        maxBytes: z.ZodInt;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"artifact-search">;
+        reference: z.ZodString;
+        query: z.ZodString;
+        maxMatches: z.ZodInt;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"shell">;
+        executable: z.ZodString;
+        args: z.ZodArray<z.ZodString>;
+        cwd: z.ZodString;
+    }, z.core.$strict>], "operation">>;
+}, z.core.$strict>;
+export type BranchAgentConversationInput = z.infer<typeof BranchAgentConversationInputSchema>;
+export declare const AgentConversationBranchReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    requestKey: z.ZodString;
+    fingerprint: z.ZodString;
+    conversationId: z.ZodString;
+    sourceConversationId: z.ZodString;
+    sourceKind: z.ZodEnum<{
+        archive: "archive";
+        conversation: "conversation";
+    }>;
+    throughRunId: z.ZodOptional<z.ZodString>;
+    sourceSeq: z.ZodInt;
+    sourceVersion: z.ZodInt;
+    sourceDigest: z.ZodString;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type AgentConversationBranchReceipt = z.infer<typeof AgentConversationBranchReceiptSchema>;
+export declare const AgentConversationBranchResultSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        created: "created";
+        duplicate: "duplicate";
+    }>;
+    receipt: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        requestKey: z.ZodString;
+        fingerprint: z.ZodString;
+        conversationId: z.ZodString;
+        sourceConversationId: z.ZodString;
+        sourceKind: z.ZodEnum<{
+            archive: "archive";
+            conversation: "conversation";
+        }>;
+        throughRunId: z.ZodOptional<z.ZodString>;
+        sourceSeq: z.ZodInt;
+        sourceVersion: z.ZodInt;
+        sourceDigest: z.ZodString;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type AgentConversationBranchResult = z.infer<typeof AgentConversationBranchResultSchema>;
+//# sourceMappingURL=branch-contract.d.ts.map

package/dist/agent-runtime/branch-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-contract.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/branch-contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuBpC,CAAC;AAEZ,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAE9F,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;kBActC,CAAC;AAEZ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,oCAAoC,CAC5C,CAAC;AAEF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;kBAKrC,CAAC;AAEZ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CACjD,OAAO,mCAAmC,CAC3C,CAAC"}

package/dist/agent-runtime/branch-events.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { AgentStoreEventEnvelope } from '../durability/events.js';
+import type { BranchIdentities } from './branch-identities.js';
+import { BranchProvider } from './branch-provider.js';
+import type { AgentMessage } from './schemas.js';
+export declare function rekeyBranchEvents(ids: BranchIdentities, source: string, events: readonly AgentStoreEventEnvelope[], retainedMessages?: ReadonlyMap<string, AgentMessage>): {
+    schemaVersion: number;
+    eventId: string;
+    conversationId: string;
+    seq: number;
+    kind: string;
+    occurredAt: string;
+    payload: z.JSONType;
+    ignorable?: true | undefined;
+}[];
+export declare function collectBranchEvent(ids: BranchIdentities, event: AgentStoreEventEnvelope): void;
+export declare function rekeyBranchEvent(ids: BranchIdentities, source: string, event: AgentStoreEventEnvelope, provider: BranchProvider): AgentStoreEventEnvelope;
+//# sourceMappingURL=branch-events.d.ts.map

package/dist/agent-runtime/branch-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-events.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/branch-events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAEpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAG5D,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAK9C,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,gBAAgB,EACrB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,uBAAuB,EAAE,EAC1C,gBAAgB,GAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAa;;;;;;;;;IAwBhE;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,gBAAgB,EAAE,KAAK,EAAE,uBAAuB,QAYvF;AAED,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,gBAAgB,EACrB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,uBAAuB,EAC9B,QAAQ,EAAE,cAAc,GACvB,uBAAuB,CAiHzB"}

package/dist/agent-runtime/branch-identities.d.ts

@@ -0,0 +1,20 @@
+import type { AgentMessage, AgentRun } from './schemas.js';
+import type { StoreOperation } from './store-reduce-shared.js';
+type IdentityKind = 'run' | 'message' | 'call' | 'approval' | 'operation' | 'spill' | 'event' | 'owner' | 'key' | 'schedule' | 'child';
+/** Definitions are collected before references are resolved; foreign references never mint IDs. */
+export declare class BranchIdentities {
+    readonly conversationId: string;
+    private readonly requestKey;
+    readonly sourceConversationId: string;
+    private readonly definitions;
+    private readonly references;
+    constructor(conversationId: string, requestKey: string, sourceConversationId: string);
+    define(kind: IdentityKind, source: string): string;
+    reference(kind: IdentityKind, source: string): string;
+    referenced(kind: IdentityKind): ReadonlySet<string>;
+    collectMessage(message: AgentMessage): void;
+    collectRun(run: AgentRun): void;
+    collectOperation(operation: StoreOperation): void;
+}
+export {};
+//# sourceMappingURL=branch-identities.d.ts.map

package/dist/agent-runtime/branch-identities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-identities.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/branch-identities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,KAAK,YAAY,GACb,KAAK,GACL,SAAS,GACT,MAAM,GACN,UAAU,GACV,WAAW,GACX,OAAO,GACP,OAAO,GACP,OAAO,GACP,KAAK,GACL,UAAU,GACV,OAAO,CAAC;AAEZ,mGAAmG;AACnG,qBAAa,gBAAgB;IAIzB,QAAQ,CAAC,cAAc,EAAE,MAAM;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,QAAQ,CAAC,oBAAoB,EAAE,MAAM;IALvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAgD;IAC5E,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAwC;IACnE,YACW,cAAc,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAC1B,oBAAoB,EAAE,MAAM,EACnC;IACJ,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAUjD;IACD,SAAS,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAOpD;IACD,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,WAAW,CAAC,MAAM,CAAC,CAElD;IACD,cAAc,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,CAM1C;IACD,UAAU,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAI9B;IACD,gBAAgB,CAAC,SAAS,EAAE,cAAc,GAAG,IAAI,CAuBhD;CACF"}

package/dist/agent-runtime/branch-messages.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { BranchIdentities } from './branch-identities.js';
+import type { AgentMessage, AgentRun } from './schemas.js';
+/** Application JSON is data, never an undocumented runtime reference codec. */
+export declare function branchOpaqueJson(value: z.infer<ReturnType<typeof z.json>>): typeof value;
+export declare function branchToolJson(ids: BranchIdentities, name: string, value: z.infer<ReturnType<typeof z.json>>, output: boolean): string | number | boolean | z.JSONType[] | {
+    [key: string]: z.JSONType;
+} | {
+    matches: {
+        line: number;
+        text: string;
+    }[];
+    reference: string;
+} | {
+    executable: string;
+    exitCode: number | null;
+    signal: string | null;
+    stdout: string;
+    stderr: string;
+    outcome: "cancelled" | "exited" | "output-limit" | "timeout";
+    artifact?: {
+        reference: string;
+        bytes: number;
+        truncated: boolean;
+        headBytes: number;
+        tailBytes: number;
+        omittedBytes: number;
+    } | undefined;
+} | null;
+export declare function branchMessage(ids: BranchIdentities, sourceConversationId: string, message: AgentMessage): AgentMessage;
+export declare function branchRun(ids: BranchIdentities, sourceConversationId: string, run: AgentRun, settled: boolean): AgentRun;
+//# sourceMappingURL=branch-messages.d.ts.map

package/dist/agent-runtime/branch-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-messages.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/branch-messages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAG5D,OAAO,KAAK,EAAE,YAAY,EAAoB,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE1E,+EAA+E;AAC/E,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,OAAO,KAAK,CAoBxF;AAgCD,wBAAgB,cAAc,CAC5B,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,EACzC,MAAM,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;SA4BhB;AA6CD,wBAAgB,aAAa,CAC3B,GAAG,EAAE,gBAAgB,EACrB,oBAAoB,EAAE,MAAM,EAC5B,OAAO,EAAE,YAAY,GACpB,YAAY,CAad;AAED,wBAAgB,SAAS,CACvB,GAAG,EAAE,gBAAgB,EACrB,oBAAoB,EAAE,MAAM,EAC5B,GAAG,EAAE,QAAQ,EACb,OAAO,EAAE,OAAO,GACf,QAAQ,CAsBV"}

package/dist/agent-runtime/branch-observations.d.ts

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import type { BranchIdentities } from './branch-identities.js';
+/** Control observations are retained under an inert kind: no state/schedule/durability reader can replay them. */
+export declare function branchObservation(ids: BranchIdentities, kind: string, raw: z.infer<ReturnType<typeof z.json>>): {
+    result: {
+        grade: "full";
+        restrictions: ("network-denied" | "process-contained" | "secrets-hidden" | "write-contained")[];
+    } | {
+        grade: "partial";
+        restrictions: ("network-denied" | "process-contained" | "secrets-hidden" | "write-contained")[];
+        gaps: ("network-denied" | "process-contained" | "secrets-hidden" | "write-contained")[];
+    } | {
+        grade: "unavailable";
+        reason: string;
+    };
+    required: ("network-denied" | "process-contained" | "secrets-hidden" | "write-contained")[];
+    missing: ("network-denied" | "process-contained" | "secrets-hidden" | "write-contained")[];
+} | {
+    name: string;
+    version: number;
+    value: z.JSONType;
+    actor: "agent" | "human" | "system";
+} | {
+    attempt: number;
+    delayMs?: number | undefined;
+    reason?: string | undefined;
+} | {
+    effectName: string;
+    phase: "intent";
+    runId: string;
+    id?: string | undefined;
+} | {
+    effectName: string;
+    phase: "accepted";
+    encoded: string;
+    via: "reconcile" | "run";
+    runId: string;
+    id?: string | undefined;
+} | {
+    effectName: string;
+    phase: "uncertain";
+    runId: string;
+    id?: string | undefined;
+} | {
+    kind: "sleep";
+    name: string;
+    deadline: number;
+    runId: string;
+    id?: string | undefined;
+} | {
+    kind: "wait";
+    event: string;
+    id: string;
+    runId: string;
+} | {
+    stepName: string;
+    encoded: string;
+    runId: string;
+    id?: string | undefined;
+} | {
+    event: string;
+    id: string;
+    encoded: string;
+    runId: string;
+} | {
+    bytes: number;
+    sha256?: string | undefined;
+    reference: string;
+} | {
+    kind?: "after" | "at" | "every" | undefined;
+    nextAt?: string | null | undefined;
+    occurrence?: number | undefined;
+    lateByMs?: number | undefined;
+    state?: string | undefined;
+    message?: string | undefined;
+    attempts?: number | undefined;
+    retryAt?: string | null | undefined;
+    terminal?: boolean | undefined;
+    skipped?: boolean | undefined;
+    id: string;
+} | {
+    childConversationId?: string | undefined;
+    parentConversationId?: string | undefined;
+    seedUptoSeq?: number | undefined;
+    budget?: z.JSONType | undefined;
+    state?: string | undefined;
+    resultReference?: string | undefined;
+    reason?: string | undefined;
+    action?: "blocking-presented" | "blocking-resolved" | "message-sent" | undefined;
+    approvalId?: string | undefined;
+    childApprovalId?: string | undefined;
+    callId?: string | undefined;
+    toolName?: string | undefined;
+    input?: z.JSONType | undefined;
+    batchId?: string | undefined;
+    kind?: string | undefined;
+    presentedAt?: string | undefined;
+    approved?: boolean | undefined;
+};
+export declare const BranchObservationSchema: z.ZodObject<{
+    sourceKind: z.ZodString;
+    payload: z.ZodJSONSchema;
+}, z.core.$strict>;
+//# sourceMappingURL=branch-observations.d.ts.map

package/dist/agent-runtime/branch-observations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-observations.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/branch-observations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAiE5D,kHAAkH;AAClH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,gBAAgB,EACrB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmFxC;AAED,eAAO,MAAM,uBAAuB;;;kBAEzB,CAAC"}

package/dist/agent-runtime/branch-provider.d.ts

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+import type { BranchIdentities } from './branch-identities.js';
+/** Provider IDs stay provider IDs; runtime call references and their content digests are rekeyed. */
+export declare class BranchProvider {
+    private readonly ids;
+    private readonly digests;
+    constructor(ids: BranchIdentities);
+    rekey(kind: string, raw: z.infer<ReturnType<typeof z.json>>): {
+        sha256: string;
+        message: {
+            role: "assistant" | "tool" | "user";
+            content: string | ({
+                type: "reasoning" | "text";
+                text: string;
+            } | {
+                type: "file";
+                data: string | {
+                    binary: true;
+                    sha256: string;
+                    bytes: number;
+                };
+                mediaType: string;
+                filename?: string | undefined;
+            } | {
+                type: "image";
+                image: string | {
+                    binary: true;
+                    sha256: string;
+                    bytes: number;
+                };
+                mediaType?: string | undefined;
+            } | {
+                type: "tool-call";
+                toolName: string;
+                toolCallId: string;
+                input: string | number | boolean | z.JSONType[] | {
+                    [key: string]: z.JSONType;
+                } | {
+                    matches: {
+                        line: number;
+                        text: string;
+                    }[];
+                    reference: string;
+                } | {
+                    executable: string;
+                    exitCode: number | null;
+                    signal: string | null;
+                    stdout: string;
+                    stderr: string;
+                    outcome: "cancelled" | "exited" | "output-limit" | "timeout";
+                    artifact?: {
+                        reference: string;
+                        bytes: number;
+                        truncated: boolean;
+                        headBytes: number;
+                        tailBytes: number;
+                        omittedBytes: number;
+                    } | undefined;
+                } | null;
+                approvalId?: undefined;
+            } | {
+                type: "tool-result";
+                toolName: string;
+                toolCallId: string;
+                output: {
+                    type: "error-text" | "text";
+                    value: string;
+                } | {
+                    type: "error-json" | "json";
+                    value: string | number | boolean | z.JSONType[] | {
+                        [key: string]: z.JSONType;
+                    } | {
+                        matches: {
+                            line: number;
+                            text: string;
+                        }[];
+                        reference: string;
+                    } | {
+                        executable: string;
+                        exitCode: number | null;
+                        signal: string | null;
+                        stdout: string;
+                        stderr: string;
+                        outcome: "cancelled" | "exited" | "output-limit" | "timeout";
+                        artifact?: {
+                            reference: string;
+                            bytes: number;
+                            truncated: boolean;
+                            headBytes: number;
+                            tailBytes: number;
+                            omittedBytes: number;
+                        } | undefined;
+                    } | null;
+                };
+                approvalId?: undefined;
+            } | {
+                type: "tool-approval-request";
+                approvalId: string;
+                toolCallId: string;
+            } | {
+                type: "tool-approval-response";
+                approved: boolean;
+                reason?: string | undefined;
+                toolCallId?: undefined;
+                approvalId: string;
+            })[];
+        };
+    } | {
+        attempt: number;
+        stepNumber: number;
+        modelId: string;
+        instructionsSha256: string;
+        sha256?: undefined;
+        message?: undefined;
+        runId: string;
+        messageShas: string[];
+        bodySha256: string;
+    } | {
+        attempt: number;
+        stepNumber: number;
+        response: {
+            id: string;
+            provider?: string | undefined;
+        };
+        sha256?: undefined;
+        message?: undefined;
+        runId: string;
+    };
+}
+//# sourceMappingURL=branch-provider.d.ts.map

package/dist/agent-runtime/branch-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-provider.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/branch-provider.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAmH5D,qGAAqG;AACrG,qBAAa,cAAc;IAEb,OAAO,CAAC,QAAQ,CAAC,GAAG;IADhC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IACrD,YAA6B,GAAG,EAAE,gBAAgB,EAAI;IACtD,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgF1D;CACF"}