@tomsun28/pizza 0.0.9 → 0.1.1

package/dist/core/runtime/ai-client.js

@@ -0,0 +1,153 @@
+function getStreamToolCall(event) {
+    const direct = event.toolCall;
+    if (direct?.type === "toolCall")
+        return direct;
+    const contentIndex = event.contentIndex;
+    const partialContent = event.partial?.content;
+    const partialBlock = Array.isArray(partialContent) && typeof contentIndex === "number" ? partialContent[contentIndex] : undefined;
+    return partialBlock?.type === "toolCall" ? partialBlock : undefined;
+}
+/** Build an EventSourcedRuntime LLMClient around the configured AI stream function. */
+export function buildLlmClientFromStreamFn(model, streamFn, options) {
+    return {
+        async complete({ messages, systemPrompt, tools, onChunk, signal }) {
+            const apiKey = options?.getApiKey ? await options.getApiKey(model.provider) : undefined;
+            const streamTools = tools?.map((tool) => ({
+                name: tool.name,
+                description: tool.description ?? "",
+                parameters: tool.input_schema,
+            }));
+            const stream = await streamFn(model, {
+                systemPrompt: systemPrompt ?? "",
+                messages: messages.filter((message) => message.role === "user" || message.role === "assistant" || message.role === "toolResult").map((message) => {
+                    if (message.role !== "toolResult") {
+                        return message;
+                    }
+                    const toolResult = message;
+                    return {
+                        role: "toolResult",
+                        toolCallId: toolResult.toolCallId,
+                        toolName: toolResult.toolName,
+                        content: toolResult.content,
+                        isError: toolResult.isError,
+                        timestamp: toolResult.timestamp,
+                    };
+                }),
+                tools: streamTools,
+            }, {
+                apiKey,
+                signal,
+                onPayload: options?.onPayload,
+                onResponse: options?.onResponse,
+                thinkingBudgets: options?.thinkingBudgets,
+                transport: options?.transport,
+            });
+            let finalMessage;
+            for await (const event of stream) {
+                switch (event.type) {
+                    case "start":
+                        break;
+                    case "text_start":
+                        onChunk?.({ kind: "text_start", contentIndex: event.contentIndex });
+                        break;
+                    case "text_delta":
+                        onChunk?.({ kind: "text_delta", contentIndex: event.contentIndex, delta: event.delta });
+                        break;
+                    case "text_end":
+                        onChunk?.({
+                            kind: "text_end",
+                            contentIndex: event.contentIndex,
+                            content: event.content,
+                        });
+                        break;
+                    case "thinking_start":
+                        onChunk?.({ kind: "thinking_start", contentIndex: event.contentIndex });
+                        break;
+                    case "thinking_delta":
+                        onChunk?.({
+                            kind: "thinking_delta",
+                            contentIndex: event.contentIndex,
+                            delta: event.delta,
+                        });
+                        break;
+                    case "thinking_end":
+                        onChunk?.({
+                            kind: "thinking_end",
+                            contentIndex: event.contentIndex,
+                            content: event.content,
+                        });
+                        break;
+                    case "toolcall_start": {
+                        const toolCall = getStreamToolCall(event);
+                        onChunk?.({
+                            kind: "toolcall_start",
+                            contentIndex: event.contentIndex,
+                            tool_call_id: event.id ?? toolCall?.id ?? "",
+                            tool_name: event.toolName ?? toolCall?.name ?? "",
+                        });
+                        break;
+                    }
+                    case "toolcall_delta":
+                        onChunk?.({ kind: "toolcall_delta", contentIndex: event.contentIndex, delta: event.delta });
+                        break;
+                    case "toolcall_end": {
+                        const toolCall = getStreamToolCall(event);
+                        onChunk?.({
+                            kind: "toolcall_end",
+                            contentIndex: event.contentIndex,
+                            tool_call_id: event.id ?? toolCall?.id ?? "",
+                            tool_name: event.toolName ?? toolCall?.name ?? "",
+                            arguments: toolCall?.arguments ?? {},
+                        });
+                        break;
+                    }
+                    case "done":
+                    case "error":
+                        finalMessage = await stream.result();
+                        break;
+                }
+            }
+            finalMessage ??= await stream.result();
+            if (!finalMessage) {
+                throw new Error("Stream ended without a terminal event");
+            }
+            const content = finalMessage.content.map((block) => {
+                if (block.type === "toolCall") {
+                    return {
+                        type: "tool_call",
+                        id: block.id,
+                        name: block.name,
+                        arguments: block.arguments,
+                    };
+                }
+                return block;
+            });
+            return {
+                content,
+                provider: finalMessage.provider,
+                model: finalMessage.model,
+                usage: {
+                    input: finalMessage.usage.input,
+                    output: finalMessage.usage.output,
+                    cache_read: finalMessage.usage.cacheRead,
+                    cache_write: finalMessage.usage.cacheWrite,
+                    total: finalMessage.usage.totalTokens,
+                    cost: finalMessage.usage.cost.total,
+                },
+                stopReason: content.some((block) => block.type === "tool_call")
+                    ? "tool_use"
+                    : finalMessage.stopReason === "toolUse"
+                        ? "tool_use"
+                        : finalMessage.stopReason,
+                errorMessage: finalMessage.errorMessage,
+            };
+        },
+    };
+}
+export function toModelConfig(model, thinkingLevel) {
+    return {
+        provider: model.provider,
+        model_id: model.id,
+        thinking_level: thinkingLevel,
+    };
+}

package/dist/core/runtime/checkpoint.d.ts

@@ -0,0 +1,12 @@
+import type { CheckpointRef, CheckpointRequest } from "./types.js";
+export interface LocalCheckpointServiceOptions {
+    workspace_id: string;
+    runtime_id: string;
+    checkpointDir: string;
+}
+export declare class LocalCheckpointService {
+    private options;
+    constructor(options: LocalCheckpointServiceOptions);
+    create(request: CheckpointRequest): CheckpointRef;
+    restore(ref: CheckpointRef): void;
+}

package/dist/core/runtime/checkpoint.js

@@ -0,0 +1,78 @@
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+const IGNORED_DIRS = new Set([".git", "node_modules", "dist", ".pizza", ".agents"]);
+export class LocalCheckpointService {
+    constructor(options) {
+        this.options = options;
+        mkdirSync(this.options.checkpointDir, { recursive: true });
+    }
+    create(request) {
+        const createdAt = Date.now();
+        const checkpointId = `ckpt_${createdAt.toString(36)}_${randomUUID().slice(0, 8)}`;
+        const path = join(this.options.checkpointDir, `${checkpointId}.json`);
+        const files = collectFileManifest(request.cwd);
+        const workspaceHash = createHash("sha256")
+            .update(files.map((file) => `${file.path}:${file.hash}:${file.size}`).join("\n"))
+            .digest("hex");
+        const manifest = {
+            checkpoint_id: checkpointId,
+            path,
+            created_at: createdAt,
+            event_head: request.event_head,
+            event_head_sequence: request.event_head_sequence,
+            label: request.label,
+            workspace_id: this.options.workspace_id,
+            runtime_id: this.options.runtime_id,
+            cwd: resolve(request.cwd),
+            workspace_hash: workspaceHash,
+            files,
+        };
+        writeFileSync(path, `${JSON.stringify(manifest, null, 2)}\n`);
+        return {
+            checkpoint_id: manifest.checkpoint_id,
+            path: manifest.path,
+            created_at: manifest.created_at,
+            event_head: manifest.event_head,
+            event_head_sequence: manifest.event_head_sequence,
+            label: manifest.label,
+        };
+    }
+    restore(ref) {
+        if (!existsSync(ref.path)) {
+            throw new Error(`Checkpoint not found: ${ref.path}`);
+        }
+        JSON.parse(readFileSync(ref.path, "utf8"));
+    }
+}
+function collectFileManifest(cwd) {
+    const root = resolve(cwd);
+    const files = [];
+    collect(root, root, files);
+    files.sort((a, b) => a.path.localeCompare(b.path));
+    return files;
+}
+function collect(root, current, files) {
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+        if (entry.name.startsWith(".") && entry.name !== ".env" && entry.name !== ".gitignore") {
+            if (entry.isDirectory() || IGNORED_DIRS.has(entry.name))
+                continue;
+        }
+        if (entry.isDirectory() && IGNORED_DIRS.has(entry.name))
+            continue;
+        const fullPath = join(current, entry.name);
+        if (entry.isDirectory()) {
+            collect(root, fullPath, files);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        const stat = statSync(fullPath);
+        const content = readFileSync(fullPath);
+        files.push({
+            path: relative(root, fullPath).replace(/\\/g, "/"),
+            hash: createHash("sha256").update(content).digest("hex"),
+            size: stat.size,
+        });
+    }
+}

package/dist/core/runtime/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Runtime Module
+ *
+ * Event-driven (reactor-based) runtime implementation.
+ */
+export * from "./reactor.js";
+export * from "./policies.js";
+export * from "./llm-types.js";
+export * from "./runtime.js";
+export * from "./types.js";
+export * from "./local-runtime.js";
+export * from "./checkpoint.js";

package/dist/core/runtime/index.js

@@ -0,0 +1,12 @@
+/**
+ * Runtime Module
+ *
+ * Event-driven (reactor-based) runtime implementation.
+ */
+export * from "./reactor.js";
+export * from "./policies.js";
+export * from "./llm-types.js";
+export * from "./runtime.js";
+export * from "./types.js";
+export * from "./local-runtime.js";
+export * from "./checkpoint.js";

package/dist/core/runtime/llm-types.d.ts

@@ -0,0 +1,99 @@
+/**
+ * LLM Client Types
+ *
+ * Shared types for the LLM client interface used by the reactor.
+ */
+import type { ContentBlock } from "../event-store/types.js";
+import type { AgentMessage } from "../agent/types.js";
+/** Model configuration */
+export interface ModelConfig {
+    provider: string;
+    model_id: string;
+    thinking_level?: string;
+}
+/** Tool definition for LLM */
+export interface ToolDefinition {
+    name: string;
+    description?: string;
+    input_schema: Record<string, unknown>;
+}
+/**
+ * Streaming chunk emitted by an LLM client during a call.
+ *
+ * Producers map provider-specific streaming events onto this minimal shape.
+ * Consumers (the reactor) translate each chunk into AGENT_MESSAGE_CHUNK events
+ * appended to the EventStore.
+ */
+export type LLMChunk = {
+    kind: "text_start";
+    contentIndex: number;
+} | {
+    kind: "text_delta";
+    contentIndex: number;
+    delta: string;
+} | {
+    kind: "text_end";
+    contentIndex: number;
+    content: string;
+} | {
+    kind: "thinking_start";
+    contentIndex: number;
+} | {
+    kind: "thinking_delta";
+    contentIndex: number;
+    delta: string;
+} | {
+    kind: "thinking_end";
+    contentIndex: number;
+    content: string;
+} | {
+    kind: "toolcall_start";
+    contentIndex: number;
+    tool_call_id: string;
+    tool_name: string;
+} | {
+    kind: "toolcall_delta";
+    contentIndex: number;
+    delta: string;
+} | {
+    kind: "toolcall_end";
+    contentIndex: number;
+    tool_call_id: string;
+    tool_name: string;
+    arguments: unknown;
+};
+/** LLM client interface */
+export interface LLMClient {
+    complete(request: {
+        messages: AgentMessage[];
+        systemPrompt?: string;
+        model: ModelConfig;
+        tools?: ToolDefinition[];
+        /**
+         * Optional streaming callback. Fires once per LLM chunk while the call
+         * is in flight. Reactors use this to emit AGENT_MESSAGE_CHUNK events to
+         * the EventStore for live UI rendering.
+         *
+         * Clients that cannot stream may simply not call this.
+         */
+        onChunk?: (chunk: LLMChunk) => void;
+        /** Abort signal for in-flight requests. */
+        signal?: AbortSignal;
+    }): Promise<LLMResponse>;
+}
+/** LLM response */
+export interface LLMResponse {
+    content: ContentBlock[];
+    provider: string;
+    model: string;
+    usage: {
+        input: number;
+        output: number;
+        cache_read: number;
+        cache_write: number;
+        total: number;
+        cost: number;
+    };
+    stopReason: "stop" | "tool_use" | "length" | "error" | "aborted";
+    errorMessage?: string;
+}

package/dist/core/runtime/llm-types.js

@@ -0,0 +1,6 @@
+/**
+ * LLM Client Types
+ *
+ * Shared types for the LLM client interface used by the reactor.
+ */
+export {};

package/dist/core/runtime/local-runtime.d.ts

@@ -0,0 +1,23 @@
+import type { ToolExecutionResult, ToolRegistry } from "../intent/types.js";
+import type { CheckpointRef, CheckpointRequest, RuntimeAdapter, RuntimeKind, RuntimeStatus, ToolExecutionRequest } from "./types.js";
+export interface LocalRuntimeAdapterOptions {
+    runtime_id?: string;
+    workspace_id: string;
+    cwd: string;
+    agentDir?: string;
+    toolRegistry: ToolRegistry;
+}
+export declare class LocalRuntimeAdapter implements RuntimeAdapter {
+    private options;
+    readonly runtime_id: string;
+    readonly workspace_id: string;
+    readonly kind: RuntimeKind;
+    private checkpointService;
+    private status;
+    constructor(options: LocalRuntimeAdapterOptions);
+    executeTool(request: ToolExecutionRequest): Promise<ToolExecutionResult>;
+    createCheckpoint(request: CheckpointRequest): Promise<CheckpointRef>;
+    restoreCheckpoint(ref: CheckpointRef): Promise<void>;
+    getStatus(): Promise<RuntimeStatus>;
+    private _getCheckpointService;
+}

package/dist/core/runtime/local-runtime.js

@@ -0,0 +1,59 @@
+import { join } from "node:path";
+import { getWorkspaceDir } from "../event-store/workspace.js";
+import { LocalCheckpointService } from "./checkpoint.js";
+export class LocalRuntimeAdapter {
+    constructor(options) {
+        this.options = options;
+        this.kind = "local";
+        this.status = "idle";
+        this.runtime_id = options.runtime_id ?? "local_runtime";
+        this.workspace_id = options.workspace_id;
+    }
+    async executeTool(request) {
+        const tool = this.options.toolRegistry.get(request.tool_name);
+        if (!tool) {
+            return {
+                content: [{ type: "text", text: `Unknown tool: ${request.tool_name}` }],
+                is_error: true,
+                error_message: `Unknown tool: ${request.tool_name}`,
+            };
+        }
+        this.status = "running";
+        try {
+            return await tool.execute(request.arguments, {
+                tool_call_id: request.tool_call_id,
+                signal: request.signal,
+                onUpdate: request.onUpdate,
+            });
+        }
+        finally {
+            this.status = "idle";
+        }
+    }
+    async createCheckpoint(request) {
+        return this._getCheckpointService().create(request);
+    }
+    async restoreCheckpoint(ref) {
+        this._getCheckpointService().restore(ref);
+    }
+    async getStatus() {
+        return {
+            runtime_id: this.runtime_id,
+            workspace_id: this.workspace_id,
+            kind: this.kind,
+            cwd: this.options.cwd,
+            status: this.status,
+        };
+    }
+    _getCheckpointService() {
+        if (!this.checkpointService) {
+            const workspaceDir = getWorkspaceDir(this.options.workspace_id, this.options.agentDir);
+            this.checkpointService = new LocalCheckpointService({
+                workspace_id: this.options.workspace_id,
+                runtime_id: this.runtime_id,
+                checkpointDir: join(workspaceDir, "checkpoints"),
+            });
+        }
+        return this.checkpointService;
+    }
+}

package/dist/core/runtime/policies.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Reactor Policies
+ *
+ * Pluggable policy objects that customize reactor behavior without coupling
+ * the reactor to heavy dependencies (SettingsManager, SessionManager, etc).
+ *
+ * Each policy is a small, testable strategy interface. Default implementations
+ * cover the common cases; richer implementations may consult settings/session state.
+ */
+import type { EventBase } from "../event-store/types.js";
+/** Decides whether and how to retry after an LLM call failure. */
+export interface RetryPolicy {
+    /** Is this error transient (retryable)? */
+    isRetryable(error: {
+        message: string;
+        statusCode?: number;
+    }): boolean;
+    /** Compute backoff delay for the given attempt (1-indexed). Return null to give up. */
+    nextDelayMs(attempt: number): number | null;
+    /** Maximum attempts before giving up. */
+    maxAttempts: number;
+}
+/** Built-in retry policy: matches the patterns historically used by the reactor. */
+export declare class DefaultRetryPolicy implements RetryPolicy {
+    maxAttempts: number;
+    private baseDelayMs;
+    private capDelayMs;
+    constructor(opts?: {
+        maxAttempts?: number;
+        baseDelayMs?: number;
+        capDelayMs?: number;
+    });
+    isRetryable(error: {
+        message: string;
+        statusCode?: number;
+    }): boolean;
+    nextDelayMs(attempt: number): number | null;
+}
+/** Reason a compaction is being requested. */
+export type CompactionReason = "manual" | "threshold" | "overflow";
+/** A single compaction operation's outcome. */
+export interface CompactionOutcome {
+    /** Marker event_id from which the summarized context begins. */
+    first_kept_event_id: string;
+    /** LLM-produced summary text. */
+    summary: string;
+    /** Estimated tokens before compaction. */
+    tokens_before: number;
+    /** Estimated tokens after compaction (post-summary context). */
+    tokens_after?: number;
+}
+/** Decides whether to compact, and how to compact when asked. */
+export interface CompactionPolicy {
+    /** Estimate current context token usage. Return 0 if unknown. */
+    estimateContextTokens(): number;
+    /** Context window size for the active model (used for threshold/overflow detection). */
+    contextWindow(): number;
+    /** Compaction threshold as a fraction of contextWindow (default 0.85 in real settings). */
+    threshold(): number;
+    /** Run the actual compaction. Should throw on failure. */
+    compact(reason: CompactionReason, signal: AbortSignal): Promise<CompactionOutcome>;
+    /** Was the just-finished assistant message an overflow signal? */
+    isOverflow(lastAssistantMessageEvent: EventBase | undefined): boolean;
+}
+/** No-op compaction policy — useful for tests and the bare reactor. */
+export declare class NoopCompactionPolicy implements CompactionPolicy {
+    estimateContextTokens(): number;
+    contextWindow(): number;
+    threshold(): number;
+    compact(): Promise<CompactionOutcome>;
+    isOverflow(): boolean;
+}

package/dist/core/runtime/policies.js

@@ -0,0 +1,37 @@
+/**
+ * Reactor Policies
+ *
+ * Pluggable policy objects that customize reactor behavior without coupling
+ * the reactor to heavy dependencies (SettingsManager, SessionManager, etc).
+ *
+ * Each policy is a small, testable strategy interface. Default implementations
+ * cover the common cases; richer implementations may consult settings/session state.
+ */
+/** Built-in retry policy: matches the patterns historically used by the reactor. */
+export class DefaultRetryPolicy {
+    constructor(opts) {
+        this.maxAttempts = opts?.maxAttempts ?? 3;
+        this.baseDelayMs = opts?.baseDelayMs ?? 1000;
+        this.capDelayMs = opts?.capDelayMs ?? 30000;
+    }
+    isRetryable(error) {
+        if (error.statusCode && [429, 500, 502, 503, 504].includes(error.statusCode))
+            return true;
+        return /overloaded|provider.?returned.?error|rate.?limit|too many requests|429|5\d{2}|service.?unavailable|server.?error|internal.?error|network.?error|connection.?(error|refused|lost)|other side closed|fetch failed|upstream.?connect|reset before headers|socket hang up|ended without|timed? out|timeout|terminated|retry delay/i.test(error.message);
+    }
+    nextDelayMs(attempt) {
+        if (attempt > this.maxAttempts)
+            return null;
+        return Math.min(this.baseDelayMs * Math.pow(2, attempt - 1), this.capDelayMs);
+    }
+}
+/** No-op compaction policy — useful for tests and the bare reactor. */
+export class NoopCompactionPolicy {
+    estimateContextTokens() { return 0; }
+    contextWindow() { return Number.MAX_SAFE_INTEGER; }
+    threshold() { return 1; }
+    async compact() {
+        throw new Error("Compaction not configured");
+    }
+    isOverflow() { return false; }
+}