@fungi.computer/shiitake 0.0.0-stage → 0.1.0

package/dist/internal/compaction/utils.js

@@ -0,0 +1,319 @@
+import * as Schema from "effect/Schema";
+const isString = Schema.is(Schema.String);
+const COMPACTION_SUMMARY_PREFIX = `The conversation history before this point was compacted into the following summary:
+
+<summary>
+`;
+const COMPACTION_SUMMARY_SUFFIX = `
+</summary>`;
+/** Pi's native compaction boundary projection, retained without a custom role. */
+export function compactionSummaryMessage(summary, timestamp) {
+    return {
+        role: "user",
+        content: [
+            {
+                type: "text",
+                text: COMPACTION_SUMMARY_PREFIX + summary + COMPACTION_SUMMARY_SUFFIX,
+            },
+        ],
+        timestamp,
+    };
+}
+export function createFileOps() {
+    return { edited: new Set(), read: new Set(), written: new Set() };
+}
+export function extractFileOpsFromMessage(message, fileOps) {
+    if (message.role !== "assistant")
+        return;
+    for (const block of message.content) {
+        if (block.type !== "toolCall")
+            continue;
+        const path = block.arguments.path;
+        if (!isString(path))
+            continue;
+        if (block.name === "edit")
+            fileOps.edited.add(path);
+        if (block.name === "read")
+            fileOps.read.add(path);
+        if (block.name === "write")
+            fileOps.written.add(path);
+    }
+}
+export function computeFileLists(fileOps) {
+    const modified = new Set([...fileOps.edited, ...fileOps.written]);
+    return {
+        modifiedFiles: [...modified].sort(),
+        readFiles: [...fileOps.read].filter((file) => !modified.has(file)).sort(),
+    };
+}
+export function formatFileOperations(readFiles, modifiedFiles) {
+    const sections = [];
+    if (readFiles.length > 0)
+        sections.push(`<read-files>\n${readFiles.join("\n")}\n</read-files>`);
+    if (modifiedFiles.length > 0)
+        sections.push(`<modified-files>\n${modifiedFiles.join("\n")}\n</modified-files>`);
+    return sections.length === 0 ? "" : `\n\n${sections.join("\n\n")}`;
+}
+const TOOL_RESULT_MAX_CHARS = 2000;
+function textContent(content) {
+    return content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text ?? "")
+        .join("");
+}
+function truncateForSummary(text) {
+    if (text.length <= TOOL_RESULT_MAX_CHARS)
+        return text;
+    const remainingCharacters = String(text.length - TOOL_RESULT_MAX_CHARS);
+    return `${text.slice(0, TOOL_RESULT_MAX_CHARS)}\n\n[... ${remainingCharacters} more characters truncated]`;
+}
+/** Pi v0.84.4's summary serialization, retained as a separate walk. */
+function serializeUserMessage(message) {
+    const content = isString(message.content)
+        ? message.content
+        : textContent(message.content);
+    return content ? `[User]: ${content}` : undefined;
+}
+function serializeAssistantMessage(message) {
+    const text = [];
+    const thinking = [];
+    const calls = [];
+    for (const block of message.content) {
+        if (block.type === "text")
+            text.push(block.text);
+        else if (block.type === "thinking")
+            thinking.push(block.thinking);
+        else {
+            const args = Object.entries(block.arguments)
+                .map(([key, value]) => `${key}=${JSON.stringify(value)}`)
+                .join(", ");
+            calls.push(`${block.name}(${args})`);
+        }
+    }
+    const parts = [];
+    if (thinking.length > 0)
+        parts.push(`[Assistant thinking]: ${thinking.join("\n")}`);
+    if (text.length > 0)
+        parts.push(`[Assistant]: ${text.join("\n")}`);
+    if (calls.length > 0)
+        parts.push(`[Assistant tool calls]: ${calls.join("; ")}`);
+    return parts;
+}
+function serializeToolResultMessage(message) {
+    const content = textContent(message.content);
+    return content ? `[Tool result]: ${truncateForSummary(content)}` : undefined;
+}
+export function serializeConversation(messages) {
+    const parts = [];
+    for (const message of messages) {
+        if (message.role === "system") {
+            const content = isString(message.content)
+                ? message.content
+                : textContent(message.content);
+            if (content)
+                parts.push(`[System]: ${content}`);
+        }
+        else if (message.role === "user") {
+            const serialized = serializeUserMessage(message);
+            if (serialized !== undefined)
+                parts.push(serialized);
+        }
+        else if (message.role === "assistant") {
+            parts.push(...serializeAssistantMessage(message));
+        }
+        else {
+            const serialized = serializeToolResultMessage(message);
+            if (serialized !== undefined)
+                parts.push(serialized);
+        }
+    }
+    return parts.join("\n\n");
+}
+const ESTIMATED_IMAGE_CHARS = 4800;
+function estimateTextAndImageContentChars(content) {
+    if (isString(content))
+        return content.length;
+    return content.reduce((chars, block) => chars +
+        (block.type === "text"
+            ? (block.text?.length ?? 0)
+            : block.type === "image"
+                ? ESTIMATED_IMAGE_CHARS
+                : 0), 0);
+}
+/** Pi's chars/4 estimator, including its image and tool-call constants. */
+export function estimateTokens(message) {
+    let chars = 0;
+    switch (message.role) {
+        case "system":
+            return Math.ceil(estimateTextAndImageContentChars(message.content) / 4);
+        case "user":
+            return Math.ceil(estimateTextAndImageContentChars(message.content) / 4);
+        case "assistant":
+            for (const block of message.content) {
+                if (block.type === "text")
+                    chars += block.text.length;
+                else if (block.type === "thinking")
+                    chars += block.thinking.length;
+                else
+                    chars += block.name.length + JSON.stringify(block.arguments).length;
+            }
+            return Math.ceil(chars / 4);
+        case "toolResult":
+            return Math.ceil(estimateTextAndImageContentChars(message.content) / 4);
+    }
+}
+function calculateContextTokens(usage) {
+    return (usage.totalTokens ||
+        usage.input + usage.output + usage.cacheRead + usage.cacheWrite);
+}
+function validAssistantUsage(message) {
+    if (message.role !== "assistant")
+        return undefined;
+    if (message.stopReason === "aborted" || message.stopReason === "error")
+        return undefined;
+    return calculateContextTokens(message.usage) > 0 ? message.usage : undefined;
+}
+export function estimateContextTokens(messages) {
+    let index = null;
+    let usageTokens = 0;
+    for (let cursor = messages.length - 1; cursor >= 0; cursor -= 1) {
+        const message = messages[cursor];
+        if (message === undefined)
+            continue;
+        const usage = validAssistantUsage(message);
+        if (usage !== undefined) {
+            index = cursor;
+            usageTokens = calculateContextTokens(usage);
+            break;
+        }
+    }
+    if (index === null) {
+        const tokens = messages.reduce((sum, message) => sum + estimateTokens(message), 0);
+        return {
+            tokens,
+            usageTokens: 0,
+            trailingTokens: tokens,
+            lastUsageIndex: null,
+        };
+    }
+    const trailingTokens = messages
+        .slice(index + 1)
+        .reduce((sum, message) => sum + estimateTokens(message), 0);
+    return {
+        tokens: usageTokens + trailingTokens,
+        usageTokens,
+        trailingTokens,
+        lastUsageIndex: index,
+    };
+}
+export function shouldCompact(contextTokens, contextWindow, settings) {
+    if (!settings.enabled)
+        return false;
+    return contextTokens > contextWindow - settings.reserveTokens;
+}
+export const DEFAULT_COMPACTION_SETTINGS = {
+    enabled: true,
+    reserveTokens: 16384,
+    keepRecentTokens: 20000,
+};
+export const SUMMARIZATION_SYSTEM_PROMPT = `You are a context summarization assistant. Your task is to read a conversation between a user and an AI coding assistant, then produce a structured summary following the exact format specified.
+
+Do NOT continue the conversation. Do NOT respond to any questions in the conversation. ONLY output the structured summary.`;
+export const SUMMARIZATION_PROMPT = `The messages above are a conversation to summarize. Create a structured context checkpoint summary that another LLM will use to continue the work.
+
+Use this EXACT format:
+
+## Goal
+[What is the user trying to accomplish? Can be multiple items if the session covers different tasks.]
+
+## Constraints & Preferences
+- [Any constraints, preferences, or requirements mentioned by user]
+- [Or "(none)" if none were mentioned]
+
+## Progress
+### Done
+- [x] [Completed tasks/changes]
+
+### In Progress
+- [ ] [Current work]
+
+### Blocked
+- [Issues preventing progress, if any]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale]
+
+## Next Steps
+1. [Ordered list of what should happen next]
+
+## Critical Context
+- [Any data, examples, or references needed to continue]
+- [Or "(none)" if not applicable]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+const UPDATE_SUMMARIZATION_INSTRUCTIONS = `Update the existing structured summary with new information. RULES:
+- PRESERVE all existing information from the previous summary
+- ADD new progress, decisions, and context from the new messages
+- UPDATE the Progress section: move items from "In Progress" to "Done" when completed
+- UPDATE "Next Steps" based on what was accomplished
+- PRESERVE exact file paths, function names, and error messages
+- If something is no longer relevant, you may remove it
+
+Use this EXACT format:
+
+## Goal
+[Preserve existing goals, add new ones if the task expanded]
+
+## Constraints & Preferences
+- [Preserve existing, add new ones discovered]
+
+## Progress
+### Done
+- [x] [Include previously done items AND newly completed items]
+
+### In Progress
+- [ ] [Current work - update based on progress]
+
+### Blocked
+- [Current blockers - remove if resolved]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale] (preserve all previous, add new)
+
+## Next Steps
+1. [Update based on current state]
+
+## Critical Context
+- [Preserve important context, add new if needed]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+export const UPDATE_SUMMARIZATION_PROMPT = `The messages above are NEW conversation messages to incorporate into the existing summary provided in <previous-summary> tags.
+
+${UPDATE_SUMMARIZATION_INSTRUCTIONS}`;
+// Pi 0.99.2's split-turn prompt (#9908): the earlier wording read as an
+// instruction to reconstruct hidden messages, which some models refused.
+export const TURN_PREFIX_SUMMARIZATION_PROMPT = `The messages above are earlier context from an ongoing conversation. Later messages are stored separately and do not need to be reconstructed.
+
+Create a concise checkpoint of the user's request and the progress shown above. This checkpoint will be placed before the later messages so the conversation can continue with the necessary context.
+
+## Original Request
+[What did the user ask for?]
+
+## Progress So Far
+- [Key decisions and work completed in these messages]
+
+## Context Needed to Continue
+- [Information from these messages needed to understand the later work]
+
+Only summarize information explicitly present above. Do not infer or recreate later messages.`;
+export function summaryFailure(response, label) {
+    if (response.stopReason === "error") {
+        const errorMessage = response.errorMessage;
+        return `${label} failed: ${errorMessage !== undefined && errorMessage.length > 0 ? errorMessage : "Unknown error"}`;
+    }
+    if (response.stopReason === "length")
+        return `${label} failed: generation hit the token cap and the summary is incomplete`;
+    return response.content.some((part) => part.type === "toolCall")
+        ? `${label} attempted to call a tool`
+        : undefined;
+}

package/dist/internal/contracts.d.ts

@@ -0,0 +1,235 @@
+import type { HostMetaOptions } from "./host-meta.js";
+import type { SessionTerminal, ShiitakeAgent } from "../client.js";
+import type { GrantsDelivery, GrantsDeliveryResult } from "./woodstock/index.js";
+import type { Json } from "../extensions.js";
+import type { ExtensionRosterV0 } from "../extensions.js";
+import type { Api, AssistantMessage, Model, MuleStreamFunction } from "@fungi.computer/mule/effect";
+import type { AccessOptions, CapabilitySource, ExecutionOptions, ModuleRegistration, Sandbox } from "@fungi.computer/mycelium";
+import type { ModelPreference } from "./model-preference.js";
+import type { WatchdogSqliteValue, WatchdogSqliteRow, WatchdogSqliteOwner, WatchdogSqliteCursor } from "@fungi.computer/watchdog";
+export { watchdogSqliteRowSchema as sqliteRowSchema } from "@fungi.computer/watchdog";
+/** Native SQLite scalar and row grammar shared with the work queue owner. */
+export type SqliteValue = WatchdogSqliteValue;
+/** Raw row grammar shared by Woodstock and Watchdog. */
+export type SqliteRow = WatchdogSqliteRow;
+/** Native rows stay raw until the query's maintained schema decodes them. */
+export type SqliteCursor = WatchdogSqliteCursor & Readonly<{
+    /** Return one raw row or throw when none exists. */
+    one: () => SqliteRow;
+}>;
+/** Synchronous SQL and transactions held by the surrounding runtime. */
+export type SqliteOwner = Omit<WatchdogSqliteOwner, "sql"> & Readonly<{
+    /** Native synchronous SQL, returning raw rows for the query owner to decode. */
+    sql: Readonly<{
+        /** Execute a statement with SQLite scalar bindings. */
+        exec: (statement: string, ...bindings: SqliteValue[]) => SqliteCursor;
+    }>;
+}>;
+/** Acquired Pi model and optional explicit Pi stream function. */
+export type ModelAcquisition = Readonly<{
+    /** Exact Pi model selected for this run. */
+    model: Model<Api>;
+    /** Optional explicit Pi stream function for custom providers and tests. */
+    stream?: MuleStreamFunction;
+    /** Provider's bounded Retry-After for a clean HTTP refusal, if reported. */
+    retryAfterMs?: (message: AssistantMessage) => number | undefined;
+    /** Release the acquired model resources. */
+    release: () => Promise<void>;
+}>;
+/** Deterministic host seam for model selection and ready egress. */
+export type ModelSource = Readonly<{
+    /** Acquire one selection and its request-scoped egress. */
+    acquire: (input: Readonly<{
+        sessionId: string;
+        preference: ModelPreference | null;
+        signal: AbortSignal;
+    }>) => Promise<ModelAcquisition>;
+    /**
+     * Read the context window of the model a run would select now, without
+     * contacting the provider. Null when the model has none; a source without
+     * this reader leaves the window unknown.
+     */
+    describe?: (input: Readonly<{
+        sessionId: string;
+        preference: ModelPreference | null;
+        signal: AbortSignal;
+    }>) => Promise<ModelDescription>;
+}>;
+/** What a Session's footer may know about its selected model. */
+export type ModelDescription = Readonly<{
+    contextWindow: number | null;
+}>;
+/** Immutable instruction snapshot captured for one run. */
+export type InstructionSnapshot = Readonly<{
+    /** Revision of the captured instruction inputs. */
+    revision: string;
+    /** Bounded instruction text for one run. */
+    text: string;
+    /** Capability modules captured with this instruction snapshot. */
+    modules?: readonly ModuleRegistration[];
+    /** Release run-scoped host resources after the accepted run settles. */
+    release?: () => void;
+}>;
+/** Host seam for one bounded instruction snapshot. */
+export type InstructionSource = Readonly<{
+    /** Load the session's bounded instruction snapshot. */
+    load: (input: Readonly<{
+        sessionId: string;
+        commandId: string;
+        signal: AbortSignal;
+    }>) => Promise<InstructionSnapshot>;
+}>;
+/** Mycelium construction inputs captured by the Shiitake-owned run scope. */
+export type ToolSource = Readonly<{
+    /** Host-owned limit for one scoped tool invocation. */
+    execution?: ExecutionOptions;
+    /** Mycelium module descriptors visible in the run scope. */
+    modules?: readonly ModuleRegistration[];
+    /**
+     * Dynamic host capability projections acquired by Mycelium. Each run acquires
+     * them with its Session in `context.session`, so a host projects only what
+     * that Session is permitted to use.
+     */
+    sources?: readonly CapabilitySource[];
+    /** Sandbox used by the scoped capability surface. */
+    sandbox: Sandbox;
+    /**
+     * The Agent-wide access defaults for every tool of the run, as data. A
+     * Session's grants the host delivered with the owner's `grants.deliver` override
+     * the default key by key. Mycelium reads them at every call; Shiitake never
+     * interprets them. Absent is full access.
+     */
+    access?: ToolAccess;
+}>;
+/** Promise host for scheduling the opaque durable reconciler. */
+export type RuntimePendingWork = Readonly<{
+    /** Immediate recovery work remains subject to the host's retry cadence. */
+    pending: boolean;
+    /** Earliest owner-supplied wall-clock candidate for the shared host wake. */
+    nextWakeAt: number | null;
+}>;
+/** Promise host for scheduling the opaque durable reconciler. */
+export type RuntimeHost = Readonly<{
+    /** Bind the one repeatable zero-input reconciliation callback. */
+    bind: (input: Readonly<{
+        reconcile: () => Promise<void>;
+        pendingWork: () => Promise<RuntimePendingWork>;
+    }>) => Promise<Readonly<{
+        /** Commit owner mutations together with the host wake guarantee. No external I/O. */
+        commit: <A>(mutation: () => Promise<A>) => Promise<A>;
+        /** Request one later reconciliation without running it inline. */
+        requestWake: () => Promise<void>;
+        /** Stop callbacks and release the bound host registration. */
+        close: () => Promise<void>;
+    }>>;
+}>;
+/**
+ * A host's disk budget for owner storage, with the platform's own measure of
+ * it. Near the budget, Shiitake refuses new Sessions and new prompts with a
+ * typed `storage_pressure` error while admitted work finishes.
+ */
+export type StorageBudget = Readonly<{
+    /**
+     * Bytes the owner database occupies now, read from the platform, such as
+     * Cloudflare's `ctx.storage.sql.databaseSize`.
+     */
+    usedBytes: () => number;
+    /** The host's budget for those bytes. */
+    budgetBytes: number;
+}>;
+/** One model's compaction token budgets; omitted fields fall back. */
+export type CompactionBudget = Readonly<{
+    /** Tokens reserved for the model's response; compaction runs past window minus this. */
+    reserveTokens?: number;
+    /** Recent tokens kept verbatim instead of summarized. */
+    keepRecentTokens?: number;
+}>;
+/**
+ * Pi's compaction settings. Each budget resolves through the exact
+ * `provider/modelId` override, then the ordinary value, then Pi's default
+ * (16384 reserve, 20000 kept). `enabled` is global and governs automatic
+ * compaction only; a manual compaction always runs.
+ */
+export type CompactionOptions = CompactionBudget & Readonly<{
+    enabled?: boolean;
+    /** Budgets keyed by exact, case-sensitive `provider/modelId`. */
+    modelOverrides?: Readonly<Record<string, CompactionBudget>>;
+}>;
+/** Validated immutable construction bag for the durable harness. */
+export type ShiitakeOptions = Readonly<{
+    /**
+     * The schema of the opaque metadata this host attaches to prompts and
+     * operator lines. Shiitake checks, stores and returns it; it never reads it.
+     */
+    meta?: HostMetaOptions;
+    /** Native owner storage and synchronous transaction capability. */
+    store: SqliteOwner;
+    /** Disk budget for `store`; absent never refuses for storage pressure. */
+    storageBudget?: StorageBudget;
+    /** Compaction budgets; absent uses Pi's defaults for every model. */
+    compaction?: CompactionOptions;
+    /** Runtime host that schedules the opaque durable reconciler. */
+    runtime: RuntimeHost;
+    /** Host model source returning Pi's own model representation. */
+    model: ModelSource;
+    /** Host instruction snapshot seam. */
+    instructions: InstructionSource;
+    /** Scoped Mycelium construction inputs, omitted when no capabilities exist. */
+    tools?: ToolSource;
+    /**
+     * The host's explicit extension roster and grants. Required: a host with no
+     * extensions passes `{ roster: [], grants: [] }`.
+     */
+    extensions: ExtensionRosterV0;
+}>;
+/**
+ * A host's access data for its Agent's tools. Grants are keyed by module id;
+ * a module an extension built is granted by that extension's id. A missing id
+ * keeps full access, so a first-time host writes no permission code.
+ */
+export type ToolAccess = Pick<AccessOptions, 
+/** The Agent-wide default; a Session's delivered grants override it. */
+"grants"
+/** Keys refused unless a delivery or the default names them: fail closed. */
+ | "required"
+/** Ask a person to approve one `confirm` call; absent refuses those calls. */
+ | "confirm"
+/** Operator-only observer of each refusal; never changes the decision. */
+ | "onRefused">;
+/**
+ * The in-process owner of a durable harness. Only the host holds it, so only
+ * the host can write a Session's grants or attach metadata; no HTTP or
+ * remote client can.
+ */
+export type ShiitakeOwnerAgent = ShiitakeAgent & Readonly<{
+    /** Each Session's delivered tool grants, read at every call. */
+    grants: Readonly<{
+        /**
+         * Store one versioned delivery of the host's decision, synchronously,
+         * so the very next tool call reads it. Versions never move back: an
+         * older one throws a conflict and writes nothing. The same version with
+         * other grants replaces them; an identical replay is `unchanged`.
+         */
+        deliver: (sessionId: string, delivery: GrantsDelivery) => GrantsDeliveryResult;
+        /** One Session's newest delivery; null when the host delivered none. */
+        read: (sessionId: string) => GrantsDelivery | null;
+    }>;
+    /**
+     * The same Agent whose prompts and operator lines carry `meta`, checked
+     * against the host's metadata schema and stored beside each message.
+     */
+    withMeta: (meta: Json) => ShiitakeAgent;
+}>;
+export type { GrantsDelivery, GrantsDeliveryResult, } from "./woodstock/index.js";
+export type { HostMetaOptions, StandardHostMetaResult, StandardHostMetaSchema, } from "./host-meta.js";
+/** Exact accepted-work facts, independent of the current Session branch or page. */
+export type CommandSettlement = Readonly<{
+    /** Durable terminal and the command that ended the work's opaque metadata. */
+    terminal: SessionTerminal;
+    /** Last completed assistant text; cancelled work returns no answer. */
+    content: string;
+    /** Provider-native usage facts, retaining model identity without transcript content. */
+    usage: readonly Pick<AssistantMessage, "provider" | "model" | "usage">[];
+    /** Distinct tool-call intentions belonging to this exact work. */
+    toolCalls: number;
+}>;

package/dist/internal/contracts.js

@@ -0,0 +1 @@
+export { watchdogSqliteRowSchema as sqliteRowSchema } from "@fungi.computer/watchdog";

package/dist/internal/coordinator.d.ts

@@ -0,0 +1,18 @@
+import type { BirdDogMail } from "@fungi.computer/bird-dog";
+import type { VerifiedAgentReply } from "./woodstock/index.js";
+import * as Effect from "effect/Effect";
+import { ShiitakeError } from "../errors.js";
+import type { Json } from "../extensions.js";
+import type { ShiitakeEffectOwner, ShiitakeEffectOptions } from "./effect-contracts.js";
+import type { RuntimeCoordinator } from "./runtime-coordinator.js";
+/** Construct the Effect-native coordinator over the private owner modules. */
+export declare function openCoordinator(options: ShiitakeEffectOptions, runtime: RuntimeCoordinator): ShiitakeEffectOwner;
+/**
+ * Accept one addressed mail envelope; the door decodes it as a prompt. `reply`
+ * is the host's authentication of a delegated Agent's reply; only then does
+ * the model see the line inside the verified-reply tag.
+ */
+export declare function acceptAddressedMail(runtime: RuntimeCoordinator, mail: BirdDogMail, meta?: Json, reply?: VerifiedAgentReply): Effect.Effect<Readonly<{
+    status: "accepted";
+    commandId: string;
+}>, ShiitakeError, never>;