@fungi.computer/shiitake 0.0.0-stage → 0.1.0

package/dist/internal/woodstock/session-entry.d.ts

@@ -0,0 +1,478 @@
+import type { Message, MuleIdentity, MuleToolResult, ToolCall, Usage, UserMessage } from "@fungi.computer/mule/effect";
+import * as Schema from "effect/Schema";
+import * as Result from "effect/Result";
+/** Provider-native usage grammar shared by stored messages and settlement facts. */
+export declare const usage: Schema.Codec<Usage>;
+/** Exact Pi message grammar stored by Woodstock without normalization. */
+export declare const StoredPiMessageSchema: Schema.Codec<Message>;
+declare const LiveRetryEventSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"auto_retry_start">;
+    readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly attempt: Schema.Number;
+    readonly maxAttempts: Schema.Number;
+    readonly delayMs: Schema.Number;
+    readonly errorMessage: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"auto_retry_attempt">;
+    readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly attempt: Schema.Number;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"auto_retry_end">;
+    readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly attempt: Schema.Number;
+    readonly success: Schema.Boolean;
+    readonly finalError: Schema.optionalKey<Schema.String>;
+}>]>;
+/**
+ * One retained Pi live-retry observation, as Woodstock stores it under its
+ * `live_retry` session entry kind. Mule's retry loop (`retryAssistantCall`
+ * wrapped around each assistant call in `packages/mule/src/effect.ts`)
+ * produces the generic `MuleRetryObservation`; `run-scope.ts` maps that onto
+ * this exact shape before calling `recordLiveRetryEvent`.
+ */
+export type LiveRetryEvent = Schema.Schema.Type<typeof LiveRetryEventSchema>;
+/** What started one compaction: the user, the context threshold, or an overflow. */
+declare const CompactionTriggerSchema: Schema.Literals<readonly ["manual", "threshold", "overflow"]>;
+/** What started one compaction. */
+export type CompactionTrigger = Schema.Schema.Type<typeof CompactionTriggerSchema>;
+/** Closed grammar stored in one retained Session entry JSON column. */
+declare const StoredSessionEntrySchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"sandbox_failure">;
+    readonly event: Schema.Struct<{
+        readonly kind: Schema.Literal<"sandbox_failure">;
+        readonly ref: Schema.String;
+        readonly executionId: Schema.String;
+        readonly adapter: Schema.String;
+        readonly buildSha: Schema.NullOr<Schema.String>;
+        readonly tag: Schema.Literals<readonly ["SourceInvalid", "GuestThrew", "DeadlineExceeded", "Cancelled", "DispatchLost", "SandboxCrashed", "BadResponse", "ResultTooLarge", "ResultNotJson", "CapabilityFailed", "Unknown"]>;
+        readonly fields: Schema.$Record<Schema.String, Schema.Codec<import("zod").JSONType, import("zod").JSONType, never, never>>;
+        readonly healthAlert: Schema.Boolean;
+    }>;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"document">;
+    readonly workId: Schema.Null;
+    readonly extensionId: Schema.String;
+    readonly name: Schema.String;
+    readonly valueJson: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"model_preference">;
+    readonly workId: Schema.Null;
+    readonly preference: Schema.NullOr<Schema.Struct<{
+        readonly providerId: Schema.String;
+        readonly modelId: Schema.String;
+        readonly reasoning: Schema.optional<Schema.Literals<readonly ["minimal", "low", "medium", "high", "xhigh", "max"]>>;
+    }>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"command">;
+    readonly meta: Schema.optionalKey<Schema.Codec<import("../../extensions.js").Json, import("../../extensions.js").Json, never, never>>;
+    /** Present only when the host admitted this line as a verified Agent reply. */
+    readonly reply: Schema.optionalKey<Schema.Struct<{
+        readonly commandId: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["completed", "failed", "interrupted", "cancelled", "outcome_unknown"]>;
+        readonly diagnostic: Schema.optionalKey<Schema.String>;
+        readonly agentId: Schema.String;
+        readonly sessionId: Schema.String;
+    }>>;
+    readonly delivery: Schema.optionalKey<Schema.Literals<readonly ["steer", "followUp"]>>;
+    readonly requestId: Schema.String;
+    readonly targetWorkId: Schema.optionalKey<Schema.String>;
+    readonly receiptId: Schema.String;
+    readonly message: Schema.Codec<UserMessage, UserMessage, never, never>;
+    readonly contract: Schema.Struct<{
+        readonly core: Schema.String;
+        readonly extensions: Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.String]>>;
+    }>;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"command">;
+    readonly work: Schema.Literal<"compact">;
+    /** The user's focus for the summary, as Pi's `/compact <instructions>`. */
+    readonly instructions: Schema.optionalKey<Schema.String>;
+    readonly meta: Schema.optionalKey<Schema.Codec<import("../../extensions.js").Json, import("../../extensions.js").Json, never, never>>;
+    readonly requestId: Schema.String;
+    readonly receiptId: Schema.String;
+    readonly timestamp: Schema.Int;
+    readonly contract: Schema.Struct<{
+        readonly core: Schema.String;
+        readonly extensions: Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.String]>>;
+    }>;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"operator">;
+    readonly workId: Schema.Null;
+    readonly requestId: Schema.String;
+    readonly author: Schema.Literals<readonly ["operator", "party"]>;
+    readonly meta: Schema.optionalKey<Schema.Codec<import("../../extensions.js").Json, import("../../extensions.js").Json, never, never>>;
+    readonly message: Schema.Struct<{
+        readonly role: Schema.Literal<"user">;
+        readonly content: Schema.String;
+        readonly timestamp: Schema.Number;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"cancellation">;
+    readonly requestId: Schema.String;
+    readonly receiptId: Schema.String;
+    readonly targetWorkId: Schema.String;
+    readonly meta: Schema.optionalKey<Schema.Codec<import("../../extensions.js").Json, import("../../extensions.js").Json, never, never>>;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"model_selection">;
+    readonly provider: Schema.String;
+    readonly model: Schema.String;
+    readonly catalogRevision: Schema.String;
+    readonly definitionRevision: Schema.String;
+    readonly selectionPolicyRevision: Schema.String;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"run_started">;
+    readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly contract: Schema.Struct<{
+        readonly core: Schema.String;
+        readonly extensions: Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.String]>>;
+    }>;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"turn_started">;
+    readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly turn: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"model_prompt">;
+    readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly turn: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly attempt: Schema.Number;
+    readonly contract: Schema.Struct<{
+        readonly core: Schema.String;
+        readonly extensions: Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.String]>>;
+    }>;
+    readonly systemPrompt: Schema.String;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"message_start">;
+    readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly turn: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly message: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly role: Schema.Literals<readonly ["assistant", "system", "toolResult", "user"]>;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"message">;
+    readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly turn: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly message: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly value: Schema.Codec<Message, Message, never, never>;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"tool_intent">;
+    readonly replay: Schema.withDecodingDefaultType<Schema.Literals<readonly ["safe", "unsafe"]>, never>;
+    readonly contract: Schema.Struct<{
+        readonly core: Schema.String;
+        readonly extensions: Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.String]>>;
+    }>;
+    readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly turn: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly toolCall: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly call: Schema.Codec<ToolCall, ToolCall, never, never>;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"tool_outcome">;
+    readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly turn: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly toolCall: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly call: Schema.Codec<ToolCall, ToolCall, never, never>;
+    readonly result: Schema.Codec<MuleToolResult, MuleToolResult, never, never>;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"live_retry">;
+    readonly event: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"auto_retry_start">;
+        readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+        readonly attempt: Schema.Number;
+        readonly maxAttempts: Schema.Number;
+        readonly delayMs: Schema.Number;
+        readonly errorMessage: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"auto_retry_attempt">;
+        readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+        readonly attempt: Schema.Number;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"auto_retry_end">;
+        readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+        readonly attempt: Schema.Number;
+        readonly success: Schema.Boolean;
+        readonly finalError: Schema.optionalKey<Schema.String>;
+    }>]>;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"compaction">;
+    readonly resumesRun: Schema.optionalKey<Schema.Boolean>;
+    readonly trigger: Schema.optionalKey<Schema.Literals<readonly ["manual", "threshold", "overflow"]>>;
+    /** Estimated context tokens right after this compaction. */
+    readonly tokensAfter: Schema.optionalKey<Schema.Number>;
+    readonly firstKeptEntryId: Schema.String;
+    readonly summary: Schema.String;
+    readonly tokensBefore: Schema.Number;
+    readonly usage: Schema.Codec<Usage, Usage, never, never>;
+    readonly contextRevision: Schema.String;
+    readonly details: Schema.optionalKey<Schema.Struct<{
+        readonly readFiles: Schema.$Array<Schema.String>;
+        readonly modifiedFiles: Schema.$Array<Schema.String>;
+    }>>;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"compaction_notice">;
+    readonly trigger: Schema.Literals<readonly ["manual", "threshold", "overflow"]>;
+    readonly result: Schema.Literals<readonly ["nothing_to_compact", "failed"]>;
+    readonly diagnostic: Schema.optionalKey<Schema.String>;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"run_terminal">;
+    readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly terminal: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly outcome: Schema.Literals<readonly ["completed", "cancelled", "failed"]>;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"work_terminal">;
+    readonly diagnostic: Schema.optionalKey<Schema.String>;
+    readonly outcome: Schema.Literals<readonly ["completed", "interrupted", "cancelled", "failed"]>;
+    readonly workId: Schema.String;
+}>]>;
+export type StoredSessionEntry = Schema.Schema.Type<typeof StoredSessionEntrySchema>;
+/** Accepted Session work: a prompt, or a manual compaction request. */
+export type CommandSessionEntry = Extract<StoredSessionEntry, {
+    kind: "command";
+}>;
+/** A manual compaction request; it carries no message. */
+export type CompactCommandEntry = Extract<CommandSessionEntry, {
+    work: "compact";
+}>;
+/** A prompt command: the only command that enters model context. */
+export type PromptCommandEntry = Exclude<CommandSessionEntry, CompactCommandEntry>;
+/** Whether accepted work is a manual compaction request. */
+export declare function isCompactCommand(entry: CommandSessionEntry): entry is CompactCommandEntry;
+/** The prompt a command carries; a compaction request carries none. */
+export declare function promptCommand(entry: StoredSessionEntry): PromptCommandEntry | undefined;
+/** When the command was accepted, as its own data records it. */
+export declare function commandTimestamp(entry: CommandSessionEntry): number;
+export type OperatorSessionEntry = Extract<StoredSessionEntry, {
+    kind: "operator";
+}>;
+/**
+ * What a later model run sees of an operator line: always a user-role note,
+ * so a human's words are never presented as the model's own output.
+ */
+export declare function operatorContextMessage(entry: OperatorSessionEntry): UserMessage;
+/**
+ * What a model run sees of an accepted command: its stored user line, wrapped
+ * as a verified Agent reply only when the host admitted it as one.
+ */
+export declare function commandContextMessage(entry: PromptCommandEntry): UserMessage;
+/**
+ * What a client sees of an operator line: the party's words as a user
+ * message, the operator's as an assistant message from provider `operator`.
+ */
+export declare function operatorClientMessage(entry: OperatorSessionEntry): Message;
+/** Decode the one JSON representation admitted by retained Session storage. */
+export declare function decodeStoredSessionEntry(value: string): Result.Result<{
+    readonly kind: "sandbox_failure";
+    readonly event: {
+        readonly kind: "sandbox_failure";
+        readonly ref: string;
+        readonly executionId: string;
+        readonly adapter: string;
+        readonly buildSha: string | null;
+        readonly tag: "Unknown" | "SourceInvalid" | "GuestThrew" | "DeadlineExceeded" | "Cancelled" | "DispatchLost" | "SandboxCrashed" | "BadResponse" | "ResultTooLarge" | "ResultNotJson" | "CapabilityFailed";
+        readonly fields: {
+            readonly [x: string]: import("zod").JSONType;
+        };
+        readonly healthAlert: boolean;
+    };
+    readonly workId: string;
+} | {
+    readonly kind: "document";
+    readonly workId: null;
+    readonly extensionId: string;
+    readonly name: string;
+    readonly valueJson: string;
+} | {
+    readonly kind: "model_preference";
+    readonly workId: null;
+    readonly preference: {
+        readonly providerId: string;
+        readonly modelId: string;
+        readonly reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+    } | null;
+} | {
+    readonly kind: "command";
+    readonly contract: {
+        readonly core: string;
+        readonly extensions: readonly (readonly [string, string])[];
+    };
+    readonly requestId: string;
+    readonly message: UserMessage;
+    readonly workId: string;
+    readonly receiptId: string;
+    readonly delivery?: "followUp" | "steer";
+    readonly meta?: import("../../extensions.js").Json;
+    readonly reply?: {
+        readonly sessionId: string;
+        readonly commandId: string;
+        readonly outcome: "completed" | "failed" | "cancelled" | "interrupted" | "outcome_unknown";
+        readonly agentId: string;
+        readonly diagnostic?: string;
+    };
+    readonly targetWorkId?: string;
+} | {
+    readonly kind: "command";
+    readonly contract: {
+        readonly core: string;
+        readonly extensions: readonly (readonly [string, string])[];
+    };
+    readonly requestId: string;
+    readonly workId: string;
+    readonly timestamp: number;
+    readonly receiptId: string;
+    readonly work: "compact";
+    readonly instructions?: string;
+    readonly meta?: import("../../extensions.js").Json;
+} | {
+    readonly kind: "operator";
+    readonly requestId: string;
+    readonly message: {
+        readonly role: "user";
+        readonly content: string;
+        readonly timestamp: number;
+    };
+    readonly workId: null;
+    readonly author: "operator" | "party";
+    readonly meta?: import("../../extensions.js").Json;
+} | {
+    readonly kind: "cancellation";
+    readonly requestId: string;
+    readonly workId: string;
+    readonly targetWorkId: string;
+    readonly receiptId: string;
+    readonly meta?: import("../../extensions.js").Json;
+} | {
+    readonly kind: "model_selection";
+    readonly provider: string;
+    readonly model: string;
+    readonly catalogRevision: string;
+    readonly definitionRevision: string;
+    readonly selectionPolicyRevision: string;
+    readonly workId: string;
+} | {
+    readonly kind: "run_started";
+    readonly run: MuleIdentity;
+    readonly contract: {
+        readonly core: string;
+        readonly extensions: readonly (readonly [string, string])[];
+    };
+    readonly workId: string;
+} | {
+    readonly kind: "turn_started";
+    readonly run: MuleIdentity;
+    readonly turn: MuleIdentity;
+    readonly workId: string;
+} | {
+    readonly kind: "model_prompt";
+    readonly run: MuleIdentity;
+    readonly turn: MuleIdentity;
+    readonly attempt: number;
+    readonly contract: {
+        readonly core: string;
+        readonly extensions: readonly (readonly [string, string])[];
+    };
+    readonly systemPrompt: string;
+    readonly workId: string;
+} | {
+    readonly kind: "message_start";
+    readonly run: MuleIdentity;
+    readonly turn: MuleIdentity;
+    readonly message: MuleIdentity;
+    readonly role: "user" | "assistant" | "system" | "toolResult";
+    readonly workId: string;
+} | {
+    readonly kind: "message";
+    readonly run: MuleIdentity;
+    readonly turn: MuleIdentity;
+    readonly message: MuleIdentity;
+    readonly value: Message;
+    readonly workId: string;
+} | {
+    readonly kind: "tool_intent";
+    readonly replay: "unsafe" | "safe";
+    readonly contract: {
+        readonly core: string;
+        readonly extensions: readonly (readonly [string, string])[];
+    };
+    readonly run: MuleIdentity;
+    readonly turn: MuleIdentity;
+    readonly toolCall: MuleIdentity;
+    readonly call: ToolCall;
+    readonly workId: string;
+} | {
+    readonly kind: "tool_outcome";
+    readonly run: MuleIdentity;
+    readonly turn: MuleIdentity;
+    readonly toolCall: MuleIdentity;
+    readonly call: ToolCall;
+    readonly result: MuleToolResult;
+    readonly workId: string;
+} | {
+    readonly kind: "live_retry";
+    readonly event: {
+        readonly type: "auto_retry_start";
+        readonly run: MuleIdentity;
+        readonly attempt: number;
+        readonly maxAttempts: number;
+        readonly delayMs: number;
+        readonly errorMessage: string;
+    } | {
+        readonly type: "auto_retry_attempt";
+        readonly run: MuleIdentity;
+        readonly attempt: number;
+    } | {
+        readonly run: MuleIdentity;
+        readonly success: boolean;
+        readonly type: "auto_retry_end";
+        readonly attempt: number;
+        readonly finalError?: string;
+    };
+    readonly workId: string;
+} | {
+    readonly kind: "compaction";
+    readonly summary: string;
+    readonly workId: string;
+    readonly usage: Usage;
+    readonly firstKeptEntryId: string;
+    readonly tokensBefore: number;
+    readonly contextRevision: string;
+    readonly resumesRun?: boolean;
+    readonly trigger?: "manual" | "threshold" | "overflow";
+    readonly tokensAfter?: number;
+    readonly details?: {
+        readonly readFiles: readonly string[];
+        readonly modifiedFiles: readonly string[];
+    };
+} | {
+    readonly kind: "compaction_notice";
+    readonly workId: string;
+    readonly result: "failed" | "nothing_to_compact";
+    readonly trigger: "manual" | "threshold" | "overflow";
+    readonly diagnostic?: string;
+} | {
+    readonly kind: "run_terminal";
+    readonly run: MuleIdentity;
+    readonly terminal: MuleIdentity;
+    readonly outcome: "completed" | "failed" | "cancelled";
+    readonly workId: string;
+} | {
+    readonly kind: "work_terminal";
+    readonly workId: string;
+    readonly outcome: "completed" | "failed" | "cancelled" | "interrupted";
+    readonly diagnostic?: string;
+}, Schema.SchemaError>;
+/** Serialize Pi's JSON representation, then validate the retained entry. */
+export declare function encodeStoredSessionEntry(entry: StoredSessionEntry): string;
+export {};