@fungi.computer/shiitake 0.0.0-stage → 0.1.0

package/dist/internal/woodstock/run-recovery.js

@@ -0,0 +1,95 @@
+/** Derive continuation from facts, without introducing a second checkpoint store. */
+export function recoverAssistantTurn(rows) {
+    const assistant = [...rows]
+        .reverse()
+        .find(({ entry }) => entry.kind === "message" && entry.value.role === "assistant");
+    if (assistant?.entry.kind !== "message" ||
+        assistant.entry.value.role !== "assistant")
+        return undefined;
+    const after = rows.filter(({ sequence }) => sequence > assistant.sequence);
+    // A later request was already dispatched. Resend that request from the
+    // completed transcript, not the previous assistant turn.
+    if (after.some(({ entry }) => entry.kind === "turn_started" ||
+        (entry.kind === "compaction" && entry.resumesRun === true) ||
+        (entry.kind === "live_retry" &&
+            entry.event.type === "auto_retry_start")))
+        return undefined;
+    const toolResults = after.flatMap(({ entry }) => entry.kind === "message" && entry.value.role === "toolResult"
+        ? [entry.value]
+        : []);
+    const tools = assistant.entry.value.content.flatMap((call) => {
+        if (call.type !== "toolCall")
+            return [];
+        const outcome = [...after]
+            .reverse()
+            .find(({ entry }) => entry.kind === "tool_outcome" && entry.call.id === call.id)?.entry;
+        if (outcome?.kind === "tool_outcome")
+            return [
+                {
+                    call,
+                    state: "completed",
+                    result: outcome.result,
+                    message: toolResults.find((result) => result.toolCallId === call.id),
+                },
+            ];
+        const intent = [...after]
+            .reverse()
+            .find(({ entry }) => entry.kind === "tool_intent" && entry.call.id === call.id)?.entry;
+        return [
+            intent?.kind === "tool_intent"
+                ? { call, state: "started", replay: intent.replay }
+                : { call, state: "pending" },
+        ];
+    });
+    return { message: assistant.entry.value, tools };
+}
+/** One visibility rule for model context and compaction, including recovered runs. */
+export function contextMessageIds(path, activeWorkId) {
+    const terminalWork = new Set(path.flatMap(({ entry }) => entry.kind === "run_terminal" ? [entry.workId] : []));
+    const messages = new Set();
+    const lastWorkAssistant = new Map();
+    for (const row of path) {
+        const entry = row.entry;
+        if (entry.kind === "message") {
+            if (entry.value.role === "assistant") {
+                lastWorkAssistant.set(entry.workId, row.id);
+            }
+            if (terminalWork.has(entry.workId) || entry.workId === activeWorkId)
+                messages.add(row.id);
+        }
+        if ((entry.kind === "compaction" && entry.resumesRun === true) ||
+            (entry.kind === "live_retry" && entry.event.type === "auto_retry_start")) {
+            const failed = lastWorkAssistant.get(entry.workId);
+            if (failed !== undefined)
+                messages.delete(failed);
+        }
+    }
+    return messages;
+}
+/** Returned assistant failures still pass through compaction; abnormal exits do not. */
+export function abnormalTerminal(rows) {
+    const reversed = [...rows].reverse();
+    const terminal = reversed.find(({ entry }) => entry.kind === "run_terminal");
+    if (terminal?.entry.kind !== "run_terminal")
+        return undefined;
+    if (rows.some(({ sequence, entry }) => sequence > terminal.sequence &&
+        (entry.kind === "run_started" ||
+            (entry.kind === "compaction" && entry.resumesRun === true))))
+        return undefined;
+    if (terminal.entry.outcome === "cancelled")
+        return "cancelled";
+    if (terminal.entry.outcome !== "failed")
+        return undefined;
+    const turn = reversed.find(({ entry }) => entry.kind === "turn_started");
+    const assistant = reversed.find(({ sequence, entry }) => entry.kind === "message" &&
+        entry.value.role === "assistant" &&
+        sequence > (turn?.sequence ?? 0));
+    return assistant?.entry.kind === "message" &&
+        assistant.entry.value.role === "assistant" &&
+        assistant.entry.value.stopReason === "error" &&
+        !rows.some(({ sequence, entry }) => sequence > assistant.sequence &&
+            entry.kind === "live_retry" &&
+            entry.event.type === "auto_retry_start")
+        ? undefined
+        : "failed";
+}

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

@@ -0,0 +1,16 @@
+import { type AttentionItem, type SessionAttention } from "../../session-attention.js";
+import type { SqliteOwner } from "../contracts.js";
+/** Woodstock owns the durable attention rows alongside their Session. */
+export declare function prepareSessionAttention(owner: SqliteOwner): void;
+/** Read the complete bounded attention projection inside the owner's transaction. */
+export declare function readSessionAttention(owner: SqliteOwner, sessionId: string): readonly SessionAttention[];
+/** Whether any owner still requests attention; no wall-clock expiry heuristic. */
+export declare function hasSessionAttention(owner: SqliteOwner, sessionId: string): boolean;
+/** Upsert only the calling extension's item, in the calling transaction. */
+export declare function setSessionAttention(owner: SqliteOwner, sessionId: string, extensionId: string, item: AttentionItem): void;
+/** Clear only the calling extension's item; an absent item is a no-op. */
+export declare function clearSessionAttention(owner: SqliteOwner, sessionId: string, extensionId: string, id: string): void;
+/** Bounded keyset traversal for refreshing an owner's attention on stop/resume. */
+export declare function readAttentionSessionPage(owner: SqliteOwner, extensionId: string, after: string): readonly string[];
+/** Apply current grants and return the bounded roster identities whose visibility changed. */
+export declare function replaceAttentionGrants(owner: SqliteOwner, ids: readonly string[]): readonly string[];

package/dist/internal/woodstock/session-attention.js

@@ -0,0 +1,88 @@
+import * as Schema from "effect/Schema";
+import { ShiitakeError } from "../../errors.js";
+import { AttentionItemSchema, maximumSessionAttention, maximumExtensionAttention, SessionAttentionSchema, } from "../../session-attention.js";
+const decodeRow = Schema.decodeUnknownSync(Schema.Struct({ extension_id: Schema.String, value_json: Schema.String }));
+const decodeItem = Schema.decodeUnknownSync(Schema.fromJsonString(AttentionItemSchema));
+const decodePublic = Schema.decodeUnknownSync(SessionAttentionSchema);
+const encodeItem = Schema.encodeSync(Schema.fromJsonString(AttentionItemSchema));
+/** Woodstock owns the durable attention rows alongside their Session. */
+export function prepareSessionAttention(owner) {
+    owner.sql.exec(`CREATE TABLE IF NOT EXISTS session_attention_grants (
+    extension_id TEXT PRIMARY KEY
+  )`);
+    owner.sql.exec(`CREATE TABLE IF NOT EXISTS session_attention (
+    session_id TEXT NOT NULL REFERENCES sessions(id),
+    extension_id TEXT NOT NULL,
+    id TEXT NOT NULL,
+    value_json TEXT NOT NULL,
+    PRIMARY KEY (session_id, extension_id, id)
+  )`);
+    owner.sql.exec("CREATE INDEX IF NOT EXISTS idx_session_attention_owner ON session_attention(extension_id, session_id)");
+}
+/** Read the complete bounded attention projection inside the owner's transaction. */
+export function readSessionAttention(owner, sessionId) {
+    return owner.sql
+        .exec("SELECT a.extension_id, a.value_json FROM session_attention a JOIN shiitake_extension_status s ON s.extension_id = a.extension_id AND s.status = 'running' JOIN session_attention_grants g ON g.extension_id = a.extension_id WHERE a.session_id = ? ORDER BY a.extension_id, a.id LIMIT ?", sessionId, maximumSessionAttention)
+        .toArray()
+        .map((raw) => {
+        const row = decodeRow(raw);
+        return decodePublic({
+            ...decodeItem(row.value_json),
+            extensionId: row.extension_id,
+        });
+    });
+}
+/** Whether any owner still requests attention; no wall-clock expiry heuristic. */
+export function hasSessionAttention(owner, sessionId) {
+    return (owner.sql
+        .exec("SELECT 1 FROM session_attention a JOIN shiitake_extension_status s ON s.extension_id = a.extension_id AND s.status = 'running' JOIN session_attention_grants g ON g.extension_id = a.extension_id WHERE a.session_id = ? LIMIT 1", sessionId)
+        .toArray().length > 0);
+}
+/** Upsert only the calling extension's item, in the calling transaction. */
+export function setSessionAttention(owner, sessionId, extensionId, item) {
+    const usage = Schema.decodeUnknownSync(Schema.Struct({ count: Schema.Int }))(owner.sql
+        .exec("SELECT COUNT(*) AS count FROM session_attention WHERE session_id = ? AND NOT (extension_id = ? AND id = ?)", sessionId, extensionId, item.id)
+        .one());
+    if (usage.count >= maximumSessionAttention)
+        throw new ShiitakeError("contract", "invalid", "Session attention capacity reached");
+    const extensionUsage = Schema.decodeUnknownSync(Schema.Struct({ count: Schema.Int }))(owner.sql
+        .exec("SELECT COUNT(*) AS count FROM session_attention WHERE extension_id = ? AND NOT (session_id = ? AND id = ?)", extensionId, sessionId, item.id)
+        .one());
+    if (extensionUsage.count >= maximumExtensionAttention)
+        throw new ShiitakeError("contract", "invalid", "Extension attention capacity reached");
+    owner.sql.exec(`INSERT INTO session_attention (session_id, extension_id, id, value_json) VALUES (?, ?, ?, ?)
+     ON CONFLICT (session_id, extension_id, id) DO UPDATE SET value_json = excluded.value_json`, sessionId, extensionId, item.id, encodeItem(item));
+}
+/** Clear only the calling extension's item; an absent item is a no-op. */
+export function clearSessionAttention(owner, sessionId, extensionId, id) {
+    owner.sql.exec("DELETE FROM session_attention WHERE session_id = ? AND extension_id = ? AND id = ?", sessionId, extensionId, id);
+}
+/** Bounded keyset traversal for refreshing an owner's attention on stop/resume. */
+export function readAttentionSessionPage(owner, extensionId, after) {
+    const decode = Schema.decodeUnknownSync(Schema.Struct({ session_id: Schema.String }));
+    return owner.sql
+        .exec("SELECT DISTINCT session_id FROM session_attention WHERE extension_id = ? AND session_id > ? ORDER BY session_id LIMIT 64", extensionId, after)
+        .toArray()
+        .map((row) => decode(row).session_id);
+}
+/** Apply current grants and return the bounded roster identities whose visibility changed. */
+export function replaceAttentionGrants(owner, ids) {
+    const decode = Schema.decodeUnknownSync(Schema.Struct({ extension_id: Schema.String }));
+    const prior = new Set(owner.sql
+        .exec("SELECT extension_id FROM session_attention_grants LIMIT 64")
+        .toArray()
+        .map((row) => decode(row).extension_id));
+    const next = new Set(ids);
+    const changed = [];
+    for (const id of prior)
+        if (!next.has(id)) {
+            owner.sql.exec("DELETE FROM session_attention_grants WHERE extension_id = ?", id);
+            changed.push(id);
+        }
+    for (const id of next)
+        if (!prior.has(id)) {
+            owner.sql.exec("INSERT INTO session_attention_grants (extension_id) VALUES (?)", id);
+            changed.push(id);
+        }
+    return changed;
+}

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

@@ -0,0 +1,18 @@
+import type { SqliteOwner } from "../contracts.js";
+import type { DocumentForkPolicyV0 } from "../../session-documents.js";
+import type { StoredSessionEntry } from "./session-entry.js";
+export type StoredDocumentSpec = Readonly<{
+    extensionId: string;
+    name: string;
+    initialJson: string;
+    fork: DocumentForkPolicyV0;
+    maxBytes: number;
+}>;
+/** Policy is durable too, so a fork never depends on a process-local extension. */
+export declare function prepareSessionDocuments(owner: SqliteOwner): void;
+/** Activation commits a validated declaration; it does not rewrite document history. */
+export declare function declareSessionDocument(owner: SqliteOwner, spec: StoredDocumentSpec): void;
+/** Baselines appended after the copied history in the same fork transaction. */
+export declare function forkDocumentEntries(owner: SqliteOwner, 
+/** Latest value on the source's current lineage, not a global last write. */
+currentValue: (extensionId: string, name: string) => string | undefined): readonly StoredSessionEntry[];

package/dist/internal/woodstock/session-documents.js

@@ -0,0 +1,51 @@
+import * as Schema from "effect/Schema";
+import { ShiitakeError } from "../../errors.js";
+const SpecRow = Schema.Struct({
+    extension_id: Schema.String,
+    name: Schema.String,
+    initial_json: Schema.String,
+    fork: Schema.Literals(["inherit-at-fork-point", "current", "fresh"]),
+    max_bytes: Schema.Int.pipe(Schema.check(Schema.isGreaterThan(0))),
+});
+/** Policy is durable too, so a fork never depends on a process-local extension. */
+export function prepareSessionDocuments(owner) {
+    owner.sql.exec(`CREATE TABLE IF NOT EXISTS session_document_specs (
+    extension_id TEXT NOT NULL, name TEXT NOT NULL, initial_json TEXT NOT NULL,
+    fork TEXT NOT NULL, max_bytes INTEGER NOT NULL,
+    PRIMARY KEY (extension_id, name)
+  )`);
+}
+/** Activation commits a validated declaration; it does not rewrite document history. */
+export function declareSessionDocument(owner, spec) {
+    owner.sql.exec(`INSERT INTO session_document_specs
+    (extension_id, name, initial_json, fork, max_bytes) VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(extension_id, name) DO UPDATE SET initial_json = excluded.initial_json,
+      fork = excluded.fork, max_bytes = excluded.max_bytes`, spec.extensionId, spec.name, spec.initialJson, spec.fork, spec.maxBytes);
+}
+/** Baselines appended after the copied history in the same fork transaction. */
+export function forkDocumentEntries(owner, 
+/** Latest value on the source's current lineage, not a global last write. */
+currentValue) {
+    const specs = owner.sql
+        .exec("SELECT extension_id, name, initial_json, fork, max_bytes FROM session_document_specs ORDER BY extension_id, name")
+        .toArray();
+    return specs.flatMap((raw) => {
+        const spec = Schema.decodeUnknownSync(SpecRow)(raw);
+        if (spec.fork === "inherit-at-fork-point")
+            return [];
+        const valueJson = spec.fork === "fresh"
+            ? spec.initial_json
+            : (currentValue(spec.extension_id, spec.name) ?? spec.initial_json);
+        if (new TextEncoder().encode(valueJson).byteLength > spec.max_bytes)
+            throw new ShiitakeError("store", "rejected", "Session document exceeds its declared size bound");
+        return [
+            {
+                kind: "document",
+                workId: null,
+                extensionId: spec.extension_id,
+                name: spec.name,
+                valueJson,
+            },
+        ];
+    });
+}