@mku1tra/que-pasa 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matthew Kelly
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,39 @@
-# Temporary Holding Version
+# que-pasa
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+que-v2's harness, on pi-durable: a workspace defines its agents with `@mku1tra/que-pasa/define`, and `@mku1tra/que-pasa/loop` runs them, durably and traced. It knows no workspace. What is built: `que-pasa.md`.
+
+## Run and check
+
+Node runs in the dev container (`.devcontainer/devcontainer.json`), never on the host. You need `just`, `podman` and `npx`.
+
+- `just up`: make or start this checkout's dev container
+- `just check`: the check set, `scripts/check.sh`: notes, then types, lint, format, tests and the build. The pre-push hook and the pipeline run the same file
+- `just run <command>`: run a command in the dev container, such as `just run npm install zod`
+- `just down`: remove this checkout's container and its own volumes
+
+## Run agents
+
+```ts
+import { openNodeSqliteStorage } from "@earendil-works/pi-durable/storage/sqlite/node";
+import { openRuntime } from "@mku1tra/que-pasa/loop";
+
+const runtime = await openRuntime({ storage: await openNodeSqliteStorage("runs.sqlite"), models, agents: [nail] });
+const result = await runtime.run(nail, input, { runId: attempt.id, caller: { id: "assembly" }, context });
+await runtime.close();
+```
+
+One runtime per process owns its SQLite file. After a crash, open it again with the same agents: unfinished runs go on, and `run` with the same `runId` gives back the result.
+
+Each run is traced as OpenTelemetry GenAI spans through `@opentelemetry/api`. To keep them, register an SDK (a tracer provider, an exporter, and an async context manager). To add what only the host knows, call `runtime.run()` inside a span of its own. `captureContent: true` on `openRuntime` adds message content.
+
+## Use it from another project
+
+Install it from npm: `npm install @mku1tra/que-pasa zod`. zod is a peer dependency: the project brings it.
+
+## Release
+
+Set the version in `package.json`, commit, land, and push its tag, `v<version>`. `.github/workflows/publish.yml` runs the check set and publishes on npm by trusted publishing (no token, with provenance). A ruleset lets only an admin of the repo make a version tag. A version npm has is not published again. A published version cannot change: npm unpublishes only within 72 hours.
+
+## Ship
+
+A change lands on main through `git land`.

package/dist/define/agent.d.ts

@@ -0,0 +1,23 @@
+import type { z } from "zod";
+import type { Json } from "./runtime.ts";
+import type { Tool } from "./tool.ts";
+/** One agent's picks from a workspace: the core every agent has. C is the context its runs are given, which its tools read. */
+export type Agent<O extends z.ZodObject | undefined = z.ZodObject | undefined, C extends Json | undefined = undefined> = {
+    /** kebab-case, as its file is named. */
+    name: string;
+    /** "provider:model-id". */
+    model: string;
+    /** What the agent is and how it works: the start of its system prompt. */
+    instructions: string;
+    /** Passed explicitly: the agent can call these and no others. */
+    tools: readonly Tool<z.ZodObject, C>[];
+    /** The shape of its result. Left out, the agent answers in chat text. */
+    output?: O;
+};
+/** A model id, "provider:model-id", as its provider and its id: throws on any other shape. */
+export declare function parseModel(model: string): {
+    provider: string;
+    modelId: string;
+};
+/** An agent, checked: its name, its model id, its instructions, and tool names that do not repeat. */
+export declare function defineAgent<O extends z.ZodObject | undefined = undefined, C extends Json | undefined = undefined>(agent: Agent<O, C>): Agent<O, C>;

package/dist/define/agent.js

@@ -0,0 +1,29 @@
+const agentName = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+const modelId = /^[^:\s]+:\S+$/;
+/** A model id, "provider:model-id", as its provider and its id: throws on any other shape. */
+export function parseModel(model) {
+    if (!modelId.test(model))
+        throw new Error(`the model must be "provider:model-id", not "${model}"`);
+    const at = model.indexOf(":");
+    return { provider: model.slice(0, at), modelId: model.slice(at + 1) };
+}
+/** An agent, checked: its name, its model id, its instructions, and tool names that do not repeat. */
+export function defineAgent(agent) {
+    if (!agentName.test(agent.name)) {
+        throw new Error(`agent "${agent.name}": the name must be kebab-case`);
+    }
+    if (!modelId.test(agent.model)) {
+        throw new Error(`agent "${agent.name}": the model must be "provider:model-id", not "${agent.model}"`);
+    }
+    if (agent.instructions.trim() === "") {
+        throw new Error(`agent "${agent.name}": the instructions are empty`);
+    }
+    const seen = new Set();
+    for (const tool of agent.tools) {
+        if (seen.has(tool.name)) {
+            throw new Error(`agent "${agent.name}": two tools are named "${tool.name}"`);
+        }
+        seen.add(tool.name);
+    }
+    return Object.freeze({ ...agent, tools: Object.freeze([...agent.tools]) });
+}

package/dist/define/index.d.ts

@@ -0,0 +1,3 @@
+export { defineAgent, parseModel, type Agent } from "./agent.ts";
+export { defineTool, type Tool } from "./tool.ts";
+export type { Caller, Json, Runtime } from "./runtime.ts";

package/dist/define/index.js

@@ -0,0 +1,2 @@
+export { defineAgent, parseModel } from "./agent.js";
+export { defineTool } from "./tool.js";

package/dist/define/runtime.d.ts

@@ -0,0 +1,17 @@
+/** The person or program a run acts for. Every run carries one: no tool or agent passes it on. */
+export type Caller = {
+    id: string;
+};
+/** A JSON value: what a run keeps in storage, so it survives a restart. */
+export type Json = string | number | boolean | null | Json[] | {
+    [key: string]: Json;
+};
+/**
+ * What a tool gets from its run, besides its input: the caller, and the context the run was given (LangChain's
+ * runtime context). The context is the host's, per run, such as the sandbox an attempt's tools exec into. It is JSON,
+ * because the run keeps it, and a run that resumes after a restart gives its tools the same one.
+ */
+export type Runtime<C extends Json | undefined = undefined> = {
+    caller: Caller;
+    context: C;
+};

package/dist/define/runtime.js

@@ -0,0 +1 @@
+export {};

package/dist/define/tool.d.ts

@@ -0,0 +1,21 @@
+import type { z } from "zod";
+import type { Json, Runtime } from "./runtime.ts";
+/** A function an agent can call: written once in a workspace, so any agent in it can be given it. */
+export type Tool<S extends z.ZodObject = z.ZodObject, C extends Json | undefined = undefined> = {
+    /** What the model calls it by: snake_case, at most 64 characters. */
+    name: string;
+    /** What it does and when to call it. The model reads it to choose. */
+    description: string;
+    /** The input the model must give. */
+    schema: S;
+    /** The name of the connection it reads at call time. The tool never holds the credential. */
+    connection?: string;
+    /**
+     * "safe": a call a crash cut off runs again when the run resumes. Left out, it never runs twice: the model gets an
+     * `interrupted` result and decides what to do. pi's own term.
+     */
+    replay?: "safe";
+    run(input: z.infer<S>, runtime: Runtime<C>): unknown;
+};
+/** A tool, checked: its name is one the model providers take, and it says what it does. */
+export declare function defineTool<S extends z.ZodObject, C extends Json | undefined = undefined>(tool: Tool<S, C>): Tool<S, C>;

package/dist/define/tool.js

@@ -0,0 +1,14 @@
+const toolName = /^[a-z][a-z0-9_]{0,63}$/;
+/** A tool, checked: its name is one the model providers take, and it says what it does. */
+export function defineTool(tool) {
+    if (!toolName.test(tool.name)) {
+        throw new Error(`tool "${tool.name}": the name must be snake_case, at most 64 characters`);
+    }
+    if (tool.description.trim() === "") {
+        throw new Error(`tool "${tool.name}": the description is empty`);
+    }
+    if (tool.connection !== undefined && tool.connection.trim() === "") {
+        throw new Error(`tool "${tool.name}": the connection name is empty`);
+    }
+    return Object.freeze({ ...tool });
+}

package/dist/loop/extension.d.ts

@@ -0,0 +1,22 @@
+import { type Extension } from "@earendil-works/pi-durable";
+import { z } from "zod";
+import type { Agent, Json } from "../define/index.ts";
+/** Any agent, as the runtime holds it. */
+export type AnyAgent = Agent<z.ZodObject | undefined, Json | undefined>;
+/** The tool an agent with an output calls to give its result. No agent tool may take its name. */
+export declare const submitTool = "submit";
+/** What a run says to an agent with an output that answered without calling submit. */
+export declare const reminder = "You have not given your result. Call submit with it.";
+/** The name of an agent's extension: stable, so a run that resumes after a restart finds the agent's code. */
+export declare const extensionName: (agent: AnyAgent) => string;
+/**
+ * An agent as one pi extension: its tools, and, for an agent with an output, the submit tool and the reminder. It holds
+ * no run's state: each call reads its run's document and transcript, so it serves every run of the agent, also one that
+ * resumes in a new process.
+ */
+export declare function agentExtension(agent: AnyAgent): Extension;
+/**
+ * The JSON Schema of what the model must give: the input shape, so a field with a default is not required. Without the
+ * `$schema` key a tool's parameters do not take.
+ */
+export declare function jsonSchema(schema: z.ZodObject): object;

package/dist/loop/extension.js

@@ -0,0 +1,91 @@
+import { defineExtension, defineTool as definePiTool, GenerationTask, hook, } from "@earendil-works/pi-durable";
+import { z } from "zod";
+import { RunDoc } from "./state.js";
+import { messagesOf, resultOf, userText } from "./transcript.js";
+/** The tool an agent with an output calls to give its result. No agent tool may take its name. */
+export const submitTool = "submit";
+/** What a run says to an agent with an output that answered without calling submit. */
+export const reminder = `You have not given your result. Call ${submitTool} with it.`;
+/** How many reminders a run sends before it ends with no result. */
+const reminders = 2;
+/** The name of an agent's extension: stable, so a run that resumes after a restart finds the agent's code. */
+export const extensionName = (agent) => `agent-${agent.name}`;
+/**
+ * An agent as one pi extension: its tools, and, for an agent with an output, the submit tool and the reminder. It holds
+ * no run's state: each call reads its run's document and transcript, so it serves every run of the agent, also one that
+ * resumes in a new process.
+ */
+export function agentExtension(agent) {
+    const { output } = agent;
+    if (output && agent.tools.some((tool) => tool.name === submitTool)) {
+        throw new Error(`agent "${agent.name}": a tool is named "${submitTool}", which its output needs`);
+    }
+    const tools = agent.tools.map(toPiTool);
+    if (output)
+        tools.push(submit(output));
+    return defineExtension({
+        name: extensionName(agent),
+        tools,
+        hooks: output ? [remind] : [],
+    });
+}
+/** A que-pasa tool as a pi tool: pi checks the arguments against the JSON Schema, zod parses them, and the run's runtime goes in. */
+function toPiTool(tool) {
+    return definePiTool({
+        name: tool.name,
+        description: tool.description,
+        parameters: jsonSchema(tool.schema),
+        ...(tool.replay ? { replay: tool.replay } : {}),
+        execute: async (args, api, context) => {
+            const result = await tool.run(tool.schema.parse(args), await runtimeOf(api, context));
+            return {
+                output: [
+                    {
+                        type: "text",
+                        text: typeof result === "string" ? result : JSON.stringify(result),
+                    },
+                ],
+            };
+        },
+    });
+}
+/** The submit tool: a result that fails the schema throws, and the model gets the error to try again. A good one is kept in the transcript, as the result's details, and ends the run. */
+function submit(output) {
+    return definePiTool({
+        name: submitTool,
+        description: "Give your final result. Call it once, when you are done.",
+        parameters: jsonSchema(output),
+        replay: "safe",
+        execute: async (args) => ({
+            output: [{ type: "text", text: "Result received." }],
+            details: output.parse(args),
+            control: { terminate: true },
+        }),
+    });
+}
+/** Reminds an agent with an output that answered without submitting, at most `reminders` times, counted in its transcript. */
+const remind = hook(GenerationTask, {
+    onYield: async (_answer, api, context) => {
+        const messages = await messagesOf(api, context);
+        if (resultOf(messages, submitTool))
+            return undefined;
+        const sent = messages.filter((message) => userText(message) === reminder).length;
+        return sent < reminders ? { continue: reminder } : undefined;
+    },
+});
+/** The runtime of the call's run, from its run document. */
+async function runtimeOf(api, context) {
+    const run = await api.snapshot(RunDoc, api.conversationId, context);
+    if (!run)
+        throw new Error("the run has no run document");
+    return { caller: run.caller, context: run.context };
+}
+/**
+ * The JSON Schema of what the model must give: the input shape, so a field with a default is not required. Without the
+ * `$schema` key a tool's parameters do not take.
+ */
+export function jsonSchema(schema) {
+    const json = z.toJSONSchema(schema, { io: "input" });
+    delete json["$schema"];
+    return json;
+}

package/dist/loop/index.d.ts

@@ -0,0 +1,2 @@
+export { reminder, submitTool } from "./extension.ts";
+export { openRuntime, type RunOptions, type RunResult, type RunUsage, type Runtime, type RuntimeOptions, } from "./runtime.ts";

package/dist/loop/index.js

@@ -0,0 +1,2 @@
+export { reminder, submitTool } from "./extension.js";
+export { openRuntime, } from "./runtime.js";

package/dist/loop/runtime.d.ts

@@ -0,0 +1,61 @@
+import type { Message, Models } from "@earendil-works/pi-ai";
+import { type Storage, type UsageState } from "@earendil-works/pi-durable";
+import type { z } from "zod";
+import { type Agent, type Caller, type Json } from "../define/index.ts";
+import { type AnyAgent } from "./extension.ts";
+/** The tokens and cost a run spent: per `provider/model-id` for model calls, and per tool for tools that report it. */
+export type RunUsage = UsageState;
+/** What a run gives back: the agent's output, checked against its schema, or its answer as text. */
+export type RunResult<O> = O extends z.ZodObject ? z.infer<O> : string;
+/** What a runtime needs: where it keeps its runs, the models it may call, and every agent it can run. */
+export type RuntimeOptions = {
+    /** pi's storage: `openNodeSqliteStorage(file)` to keep runs across restarts, `MemoryStorage` to keep none. */
+    storage: Storage;
+    /** The host's models, with its providers set. */
+    models: Models;
+    /** Every agent the host can run. A run that resumes after a restart finds its agent here, by name. */
+    agents: readonly AnyAgent[];
+    /**
+     * Record message content in the trace: instructions, tool definitions, messages, tool arguments and results. Off by
+     * default, as the GenAI conventions say: content can hold sensitive data.
+     */
+    captureContent?: boolean;
+};
+/** What a run needs besides the agent and its input. */
+export type RunOptions<C extends Json | undefined> = {
+    /**
+     * The host's id for the run. A run started again with the same id is the same run: it goes on from where it is, or
+     * gives back its result, and its input, caller, model and context are the ones it was started with.
+     */
+    runId: string;
+    /** Who the run acts for. */
+    caller: Caller;
+    /** The model to run on, "provider:model-id", in place of the agent's: such as a fallback for a retry. */
+    model?: string;
+    /** Stops the run: run() rejects with the signal's reason, and no tool or model call starts after it. */
+    signal?: AbortSignal;
+    /** Called once when the run ends, answered or not, with what it spent. */
+    onUsage?: (usage: RunUsage) => void;
+    /**
+     * Called once when the run ends, answered or not, with its whole conversation in order, as pi-ai's messages: the
+     * input, each assistant message with its tool calls, each tool result, and the reminders the run sent. The system
+     * prompt is the agent's instructions, and is not in it.
+     */
+    onMessages?: (messages: Message[]) => void;
+} & (undefined extends C ? {
+    context?: C;
+} : {
+    context: C;
+});
+/** A host's agents on one pi harness: open once per process, run any number of runs, close at the end. */
+export type Runtime = {
+    /** Run one agent on one input to its result, or go on with the run of this `runId`. */
+    run<O extends z.ZodObject | undefined, C extends Json | undefined>(agent: Agent<O, C>, input: string, options: RunOptions<C>): Promise<RunResult<O>>;
+    /** Close the harness. A run still going is kept, and goes on when a runtime opens on the same storage. */
+    close(): Promise<void>;
+};
+/**
+ * Open a runtime: one pi harness on `storage`, with each agent installed as its own extension. Runs a crash left
+ * unfinished go on at once.
+ */
+export declare function openRuntime({ storage, models, agents, captureContent, }: RuntimeOptions): Promise<Runtime>;

package/dist/loop/runtime.js

@@ -0,0 +1,132 @@
+import { BACKGROUND_CONTEXT, withAbortSignal, } from "@earendil-works/chord/context";
+import { configure, createRegistry, Harness, UsageDoc, } from "@earendil-works/pi-durable";
+import { parseModel, } from "../define/index.js";
+import { agentExtension, submitTool } from "./extension.js";
+import { RunDoc, RunIndex } from "./state.js";
+import { activeParent, createTracing } from "./trace.js";
+import { answerOf, messagesOf, resultOf } from "./transcript.js";
+const context = BACKGROUND_CONTEXT;
+/**
+ * Open a runtime: one pi harness on `storage`, with each agent installed as its own extension. Runs a crash left
+ * unfinished go on at once.
+ */
+export async function openRuntime({ storage, models, agents, captureContent = false, }) {
+    const installed = new Map();
+    for (const agent of agents) {
+        if (installed.has(agent.name))
+            throw new Error(`two agents are named "${agent.name}"`);
+        installed.set(agent.name, { agent, extension: agentExtension(agent) });
+    }
+    const tracing = createTracing({
+        agents: new Map([...installed].map(([name, { agent }]) => [name, agent])),
+        captureContent,
+    });
+    const registry = createRegistry();
+    for (const { extension } of installed.values())
+        registry.install(extension);
+    registry.install(tracing.extension);
+    const harness = await Harness.open(storage, { models, registry }, context);
+    tracing.bind(harness);
+    harness.resume();
+    /**
+     * The run's conversation: made with its agent, its model and its run document in one commit, or the one this run id
+     * already has, which keeps what it was started with.
+     */
+    async function conversationOf(agent, extension, start) {
+        const { runId } = start;
+        const id = await harness.commit(async (tx) => {
+            const index = await tx.doc(RunIndex, runId, null);
+            if (index.conversationId !== null) {
+                const kept = await tx.doc(RunDoc, index.conversationId);
+                if (kept.agent !== agent.name) {
+                    throw new Error(`run "${runId}" is of agent "${kept.agent}", not "${agent.name}"`);
+                }
+                return index.conversationId;
+            }
+            const { id } = await tx.createConversation({
+                ownership: { kind: "ownerless" },
+            });
+            await configure(tx, id, {
+                model: parseModel(start.model),
+                instructions: agent.instructions,
+                extensions: [extension, tracing.extension],
+            });
+            Object.assign(await tx.doc(RunDoc, id), start);
+            index.conversationId = id;
+            tracing.start(id);
+            return id;
+        }, context);
+        const conversation = await harness.conversation(id, context);
+        if (!conversation)
+            throw new Error(`run "${runId}": its conversation is missing`);
+        return conversation;
+    }
+    async function run(agent, input, options) {
+        const entry = installed.get(agent.name);
+        if (entry?.agent !== agent) {
+            throw new Error(`agent "${agent.name}" was not given when the runtime opened`);
+        }
+        options.signal?.throwIfAborted();
+        const { runId, caller, signal, onUsage, onMessages } = options;
+        const model = options.model ?? agent.model;
+        parseModel(model);
+        const parent = activeParent();
+        const conversation = await conversationOf(agent, entry.extension, {
+            runId,
+            agent: agent.name,
+            model,
+            caller,
+            ...(options.context === undefined ? {} : { context: options.context }),
+            ...(parent === undefined ? {} : { trace: parent }),
+        });
+        let messages;
+        const transcript = async () => (messages ??= await messagesOf(conversation, context));
+        try {
+            // The same request id finds the run's input when it is in already: a run started again never runs twice.
+            const submission = await conversation.submit({ type: "input", content: input, requestId: runId }, context);
+            const settled = await waitFor(submission, conversation, signal);
+            if (settled.status !== "done") {
+                throw new Error(`agent "${agent.name}": the run ended with no answer (${settled.reason})`);
+            }
+            if (!agent.output)
+                return answerOf(await transcript());
+            const result = resultOf(await transcript(), submitTool);
+            if (!result)
+                throw new Error(`agent "${agent.name}": the run ended with no ${submitTool}`);
+            return result.value;
+        }
+        finally {
+            // The run's trace ends before run() does, so a host's span around it holds the whole run.
+            await tracing.ended(conversation.id);
+            onUsage?.((await harness.snapshot(UsageDoc, conversation.id, context)) ?? {
+                models: {},
+                tools: {},
+            });
+            onMessages?.(await transcript());
+        }
+    }
+    return {
+        run,
+        async close() {
+            await tracing.closeAll();
+            await harness.close(context);
+        },
+    };
+}
+/**
+ * Wait for the run to settle. On abort, pi cancels only the wait and never the work, so the conversation is aborted
+ * too: its tasks stop, and the run rejects with the signal's reason.
+ */
+async function waitFor(submission, conversation, signal) {
+    if (!signal)
+        return submission.wait(context);
+    try {
+        return await submission.wait(withAbortSignal(signal, context));
+    }
+    catch (error) {
+        if (!signal.aborted)
+            throw error;
+        await conversation.abort(context);
+        throw signal.reason;
+    }
+}

package/dist/loop/state.d.ts

@@ -0,0 +1,28 @@
+import { type ConversationId } from "@earendil-works/pi-durable";
+import type { Caller, Json } from "../define/index.ts";
+/** A span a run's trace hangs from, as plain JSON: the ids of OpenTelemetry's span context. */
+export type TraceParent = {
+    traceId: string;
+    spanId: string;
+    traceFlags: number;
+};
+/** What a run keeps besides its transcript: who it is for, and what its tools are given. One per run's conversation. */
+export type RunState = {
+    /** The host's id for the run. */
+    runId: string;
+    /** The agent it runs. */
+    agent: string;
+    /** The model it runs on, "provider:model-id": the agent's, or the one the run was started with. */
+    model: string;
+    caller: Caller;
+    /** Absent when the run was given none. */
+    context?: Json;
+    /** The parent of each of its trace's segments: the host's span it was started in, or its first segment. */
+    trace?: TraceParent;
+};
+/** The run's own document, written in the commit that makes its conversation. */
+export declare const RunDoc: import("@earendil-works/pi-durable").ConversationDocToken<RunState>;
+/** Where a run is: its conversation, one document per run id, so a run started again finds the one it started. */
+export declare const RunIndex: import("@earendil-works/pi-durable").SessionDocFamilyToken<{
+    conversationId: ConversationId | null;
+}, null>;

package/dist/loop/state.js

@@ -0,0 +1,20 @@
+import { defineDoc, defineDocFamily, } from "@earendil-works/pi-durable";
+/** The run's own document, written in the commit that makes its conversation. */
+export const RunDoc = defineDoc({
+    kind: "que-pasa.run",
+    version: 1,
+    scope: "conversation",
+    history: "latest",
+    fork: "initial",
+    initial: () => ({ runId: "", agent: "", model: "", caller: { id: "" } }),
+    checkpointWhen: () => true,
+});
+/** Where a run is: its conversation, one document per run id, so a run started again finds the one it started. */
+export const RunIndex = defineDocFamily({
+    kind: "que-pasa.run-index",
+    version: 1,
+    scope: "session",
+    family: true,
+    initial: () => ({ conversationId: null }),
+    checkpointWhen: () => true,
+});

package/dist/loop/trace.d.ts

@@ -0,0 +1,37 @@
+/**
+ * A run's trace: OpenTelemetry spans in the GenAI conventions (semconv 1.43.0), made live from pi's hooks, through the
+ * OpenTelemetry API only. The host owns the SDK and the exporter; with none, every call here is a no-op.
+ *
+ *   invoke_agent <agent>     one per process that works on the run: a segment
+ *   ├─ chat <model>          one per model request
+ *   ├─ execute_tool <tool>   one per tool call, submit included
+ *   └─ que_pasa.reminder     an event per reminder the run sent
+ *
+ * A segment's parent is the trace parent its run document keeps: the host's span when the run was started in one, or
+ * else the run's first segment. So every segment of a run, also one that resumes after a crash in a new process, is in
+ * one trace. Message content is recorded only when the host asks for it.
+ */
+import { type ConversationId, type Extension, type Harness } from "@earendil-works/pi-durable";
+import { type AnyAgent } from "./extension.ts";
+import { type TraceParent } from "./state.ts";
+/** The trace extension's name: every run's conversation selects it, after its agent's. */
+export declare const traceExtensionName = "que-pasa.trace";
+/** The trace parent to keep for a run started now: the host's active span, if it has one. */
+export declare function activeParent(): TraceParent | undefined;
+/** The tracing of one runtime: its pi extension, and the segments of the runs it works on in this process. */
+export declare function createTracing({ agents, captureContent, }: {
+    agents: ReadonlyMap<string, AnyAgent>;
+    captureContent: boolean;
+}): {
+    extension: Extension;
+    /** The harness the segments read and wait on: bound once it is open, before any run goes on. */
+    bind(on: Harness): void;
+    /** A run this process started, so its first segment is not a resumed one. */
+    start(id: ConversationId): void;
+    /** Settles when the run's segment in this process, if it has one, has ended. */
+    ended(id: ConversationId): Promise<void>;
+    /** End every open segment: the runs are kept, and go on in the next process, in a segment of their own. */
+    closeAll(): Promise<void>;
+};
+/** The hash of what makes the agent what it is on this model: its instructions, its tools, its output and the model. */
+export declare function versionOf(agent: AnyAgent, model: string): string;

package/dist/loop/trace.js

@@ -0,0 +1,373 @@
+/**
+ * A run's trace: OpenTelemetry spans in the GenAI conventions (semconv 1.43.0), made live from pi's hooks, through the
+ * OpenTelemetry API only. The host owns the SDK and the exporter; with none, every call here is a no-op.
+ *
+ *   invoke_agent <agent>     one per process that works on the run: a segment
+ *   ├─ chat <model>          one per model request
+ *   ├─ execute_tool <tool>   one per tool call, submit included
+ *   └─ que_pasa.reminder     an event per reminder the run sent
+ *
+ * A segment's parent is the trace parent its run document keeps: the host's span when the run was started in one, or
+ * else the run's first segment. So every segment of a run, also one that resumes after a crash in a new process, is in
+ * one trace. Message content is recorded only when the host asks for it.
+ */
+import { createHash } from "node:crypto";
+import { BACKGROUND_CONTEXT, } from "@earendil-works/chord/context";
+import { defineExtension, GenerationTask, hook, ToolTask, UsageDoc, } from "@earendil-works/pi-durable";
+import { context as otel, diag, ROOT_CONTEXT, SpanKind, SpanStatusCode, trace, } from "@opentelemetry/api";
+import { ATTR_ERROR_TYPE } from "@opentelemetry/semantic-conventions";
+import { ATTR_ENDUSER_ID, ATTR_GEN_AI_AGENT_NAME, ATTR_GEN_AI_AGENT_VERSION, ATTR_GEN_AI_CONVERSATION_ID, ATTR_GEN_AI_INPUT_MESSAGES, ATTR_GEN_AI_OPERATION_NAME, ATTR_GEN_AI_OUTPUT_MESSAGES, ATTR_GEN_AI_PROVIDER_NAME, ATTR_GEN_AI_REQUEST_MODEL, ATTR_GEN_AI_RESPONSE_FINISH_REASONS, ATTR_GEN_AI_RESPONSE_ID, ATTR_GEN_AI_RESPONSE_MODEL, ATTR_GEN_AI_SYSTEM_INSTRUCTIONS, ATTR_GEN_AI_TOOL_CALL_ARGUMENTS, ATTR_GEN_AI_TOOL_CALL_ID, ATTR_GEN_AI_TOOL_CALL_RESULT, ATTR_GEN_AI_TOOL_DEFINITIONS, ATTR_GEN_AI_TOOL_NAME, ATTR_GEN_AI_TOOL_TYPE, ATTR_GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS, ATTR_GEN_AI_USAGE_INPUT_TOKENS, ATTR_GEN_AI_USAGE_OUTPUT_TOKENS, ATTR_GEN_AI_USAGE_REASONING_OUTPUT_TOKENS, GEN_AI_OPERATION_NAME_VALUE_CHAT, GEN_AI_OPERATION_NAME_VALUE_EXECUTE_TOOL, GEN_AI_OPERATION_NAME_VALUE_INVOKE_AGENT, } from "@opentelemetry/semantic-conventions/incubating";
+import { parseModel } from "../define/index.js";
+import { jsonSchema, reminder, submitTool, } from "./extension.js";
+import { RunDoc } from "./state.js";
+import { messagesOf, resultOf } from "./transcript.js";
+/** The trace extension's name: every run's conversation selects it, after its agent's. */
+export const traceExtensionName = "que-pasa.trace";
+const tracer = trace.getTracer("que-pasa");
+/** The trace parent to keep for a run started now: the host's active span, if it has one. */
+export function activeParent() {
+    const span = trace.getSpanContext(otel.active());
+    return span && trace.isSpanContextValid(span) ? parentOf(span) : undefined;
+}
+/** The tracing of one runtime: its pi extension, and the segments of the runs it works on in this process. */
+export function createTracing({ agents, captureContent, }) {
+    let harness;
+    /** The runs this process started: a segment of any other run is a resumed one. */
+    const started = new Set();
+    const segments = new Map();
+    /** The run's segment in this process, opened on first use. Undefined for a conversation that is no run's. */
+    function segmentOf(id, reader, context) {
+        let segment = segments.get(id);
+        if (!segment) {
+            segment = open(id, reader, context);
+            segments.set(id, segment);
+        }
+        return segment;
+    }
+    async function open(id, reader, context) {
+        const run = await reader.snapshot(RunDoc, id, context);
+        const agent = run && agents.get(run.agent);
+        if (!run || !agent || !harness)
+            return undefined;
+        const parent = run.trace
+            ? trace.setSpanContext(ROOT_CONTEXT, { ...run.trace, isRemote: true })
+            : ROOT_CONTEXT;
+        const span = tracer.startSpan(`${GEN_AI_OPERATION_NAME_VALUE_INVOKE_AGENT} ${agent.name}`, {
+            kind: SpanKind.INTERNAL,
+            attributes: runAttributes(agent, run, !started.has(id), captureContent),
+        }, parent);
+        const segment = { span, tools: new Map(), ended: false };
+        // The run's first segment is the parent of the ones after it, when the run has no host span to keep.
+        if (!run.trace && trace.isSpanContextValid(span.spanContext())) {
+            await harness.commit(async (tx) => {
+                (await tx.doc(RunDoc, id)).trace = parentOf(span.spanContext());
+            }, BACKGROUND_CONTEXT);
+        }
+        segment.done = endWhenSettled(harness, id, run.runId, agent, segment);
+        return segment;
+    }
+    /**
+     * The segment's one owner of its end: the run's settlement, with its usage, its status and, opted in, its input and
+     * output. A run whose agent has an output and ended with no submit failed, as run() reports it.
+     */
+    async function endWhenSettled(on, id, runId, agent, segment) {
+        try {
+            const record = await on.commit((tx) => tx.submissionByRequest(id, runId), BACKGROUND_CONTEXT);
+            const submission = record && (await on.submission(record.id, BACKGROUND_CONTEXT));
+            const settled = await submission?.wait(BACKGROUND_CONTEXT);
+            const conversation = await on.conversation(id, BACKGROUND_CONTEXT);
+            if (!settled || !conversation || segment.ended)
+                return;
+            const messages = await messagesOf(conversation, BACKGROUND_CONTEXT);
+            const spent = Object.values((await on.snapshot(UsageDoc, id, BACKGROUND_CONTEXT))?.models ?? {});
+            const total = (count) => spent.reduce((sum, usage) => sum + count(usage), 0);
+            segment.span.setAttributes({
+                [ATTR_GEN_AI_USAGE_INPUT_TOKENS]: total((u) => u.input + u.cacheRead + u.cacheWrite),
+                [ATTR_GEN_AI_USAGE_OUTPUT_TOKENS]: total((u) => u.output),
+                [ATTR_GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS]: total((u) => u.cacheRead),
+                ...(captureContent ? runContent(messages) : {}),
+            });
+            const failure = settled.status !== "done"
+                ? settled.reason
+                : agent.output && !resultOf(messages, submitTool)
+                    ? "no_submit"
+                    : undefined;
+            end(segment, failure);
+        }
+        catch (error) {
+            // A close ends the wait; closeAll has ended the segment.
+            if (!segment.ended)
+                diag.error("que-pasa: a run's trace could not end", error);
+        }
+    }
+    /** End a segment and anything still open in it, with the run's failure as the error, if it failed. */
+    function end(segment, failure) {
+        segment.ended = true;
+        for (const open of [segment.chat, ...segment.tools.values()]) {
+            if (open)
+                fail(open, failure ?? "run_ended").end();
+        }
+        if (failure)
+            fail(segment.span, failure);
+        segment.span.end();
+    }
+    const traced = defineExtension({
+        name: traceExtensionName,
+        hooks: [
+            hook(GenerationTask, {
+                beforeRequest: (request, api, context) => safely(async () => {
+                    const segment = await segmentOf(api.conversationId, api, context);
+                    if (!segment)
+                        return;
+                    // A request that never answered: an attempt the abort or a retry left behind.
+                    if (segment.chat)
+                        fail(segment.chat, "superseded").end();
+                    const last = request.messages.at(-1);
+                    if (last?.role === "user" && textOf(last.content) === reminder)
+                        segment.span.addEvent("que_pasa.reminder");
+                    const run = await api.snapshot(RunDoc, api.conversationId, context);
+                    const model = parseModel(run?.model ?? "");
+                    segment.chat = tracer.startSpan(`${GEN_AI_OPERATION_NAME_VALUE_CHAT} ${model.modelId}`, {
+                        kind: SpanKind.CLIENT,
+                        attributes: {
+                            [ATTR_GEN_AI_OPERATION_NAME]: GEN_AI_OPERATION_NAME_VALUE_CHAT,
+                            [ATTR_GEN_AI_PROVIDER_NAME]: model.provider,
+                            [ATTR_GEN_AI_REQUEST_MODEL]: model.modelId,
+                            ...(captureContent
+                                ? {
+                                    [ATTR_GEN_AI_INPUT_MESSAGES]: json(request.messages.map(toGenAi)),
+                                }
+                                : {}),
+                        },
+                    }, trace.setSpan(ROOT_CONTEXT, segment.span));
+                }),
+                afterResponse: (message, api, context) => safely(async () => {
+                    const segment = await segmentOf(api.conversationId, api, context);
+                    if (!segment?.chat)
+                        return;
+                    segment.chat.setAttributes(responseAttributes(message, captureContent));
+                    if (message.stopReason === "error" ||
+                        message.stopReason === "aborted")
+                        fail(segment.chat, message.stopReason);
+                    segment.chat.end();
+                    delete segment.chat;
+                }),
+            }),
+            hook(ToolTask, {
+                beforeTool: (call, api, context) => safely(async () => {
+                    const segment = await segmentOf(api.conversationId, api, context);
+                    if (segment)
+                        segment.tools.set(call.id, toolSpan(segment, call, captureContent));
+                }),
+                afterTool: (call, result, api, context) => safely(async () => {
+                    const segment = await segmentOf(api.conversationId, api, context);
+                    if (!segment)
+                        return;
+                    // A result pi wrote with no call in this process, such as an interrupted one after a resume, starts here.
+                    const span = segment.tools.get(call.id) ??
+                        toolSpan(segment, call, captureContent);
+                    segment.tools.delete(call.id);
+                    if (captureContent)
+                        span.setAttribute(ATTR_GEN_AI_TOOL_CALL_RESULT, textOf(result.output ?? []));
+                    if (result.isError)
+                        fail(span, result.diagnostics?.[0]?.code ?? "tool_error");
+                    span.end();
+                }),
+            }),
+        ],
+    });
+    return {
+        extension: traced,
+        /** The harness the segments read and wait on: bound once it is open, before any run goes on. */
+        bind(on) {
+            harness = on;
+        },
+        /** A run this process started, so its first segment is not a resumed one. */
+        start(id) {
+            started.add(id);
+        },
+        /** Settles when the run's segment in this process, if it has one, has ended. */
+        async ended(id) {
+            await (await segments.get(id))?.done;
+        },
+        /** End every open segment: the runs are kept, and go on in the next process, in a segment of their own. */
+        async closeAll() {
+            for (const pending of segments.values()) {
+                const segment = await pending;
+                if (segment && !segment.ended) {
+                    segment.span.addEvent("que_pasa.closed");
+                    end(segment, undefined);
+                }
+            }
+            segments.clear();
+        },
+    };
+}
+/** The attributes of a run's invoke_agent span: what the run is, and, opted in, what its agent was given. */
+function runAttributes(agent, run, resumed, captureContent) {
+    const model = parseModel(run.model);
+    const tools = toolDefinitions(agent);
+    return {
+        [ATTR_GEN_AI_OPERATION_NAME]: GEN_AI_OPERATION_NAME_VALUE_INVOKE_AGENT,
+        [ATTR_GEN_AI_AGENT_NAME]: agent.name,
+        [ATTR_GEN_AI_AGENT_VERSION]: versionOf(agent, run.model),
+        [ATTR_GEN_AI_CONVERSATION_ID]: run.runId,
+        [ATTR_GEN_AI_PROVIDER_NAME]: model.provider,
+        [ATTR_GEN_AI_REQUEST_MODEL]: model.modelId,
+        [ATTR_ENDUSER_ID]: run.caller.id,
+        "que_pasa.resumed": resumed,
+        ...(captureContent
+            ? {
+                [ATTR_GEN_AI_SYSTEM_INSTRUCTIONS]: json([
+                    { type: "text", content: agent.instructions },
+                ]),
+                [ATTR_GEN_AI_TOOL_DEFINITIONS]: json(tools),
+            }
+            : {}),
+    };
+}
+/** The tools as the model is given them: the agent's, and submit when it has an output. */
+function toolDefinitions(agent) {
+    const tools = agent.tools.map((tool) => ({
+        type: "function",
+        name: tool.name,
+        description: tool.description,
+        parameters: jsonSchema(tool.schema),
+    }));
+    return agent.output
+        ? [
+            ...tools,
+            {
+                type: "function",
+                name: submitTool,
+                parameters: jsonSchema(agent.output),
+            },
+        ]
+        : tools;
+}
+/** The hash of what makes the agent what it is on this model: its instructions, its tools, its output and the model. */
+export function versionOf(agent, model) {
+    const parts = {
+        instructions: agent.instructions,
+        tools: toolDefinitions(agent),
+        model,
+    };
+    return createHash("sha256").update(JSON.stringify(parts)).digest("hex");
+}
+/** A run's input and output, opted in: its first user message, and its submit's arguments or its last answer. */
+function runContent(messages) {
+    const input = messages.find((message) => message.role === "user");
+    const output = messages.findLast((message) => message.role === "assistant");
+    return {
+        ...(input ? { [ATTR_GEN_AI_INPUT_MESSAGES]: json([toGenAi(input)]) } : {}),
+        ...(output
+            ? { [ATTR_GEN_AI_OUTPUT_MESSAGES]: json([toGenAi(output)]) }
+            : {}),
+    };
+}
+function responseAttributes(message, captureContent) {
+    return {
+        [ATTR_GEN_AI_RESPONSE_MODEL]: message.model,
+        ...(message.responseId
+            ? { [ATTR_GEN_AI_RESPONSE_ID]: message.responseId }
+            : {}),
+        [ATTR_GEN_AI_RESPONSE_FINISH_REASONS]: [message.stopReason],
+        // The conventions count input tokens with the cached ones in; pi-ai counts them apart.
+        [ATTR_GEN_AI_USAGE_INPUT_TOKENS]: message.usage.input + message.usage.cacheRead + message.usage.cacheWrite,
+        [ATTR_GEN_AI_USAGE_OUTPUT_TOKENS]: message.usage.output,
+        [ATTR_GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS]: message.usage.cacheRead,
+        ...(message.usage.reasoning === undefined
+            ? {}
+            : {
+                [ATTR_GEN_AI_USAGE_REASONING_OUTPUT_TOKENS]: message.usage.reasoning,
+            }),
+        ...(captureContent
+            ? { [ATTR_GEN_AI_OUTPUT_MESSAGES]: json([toGenAi(message)]) }
+            : {}),
+    };
+}
+function toolSpan(segment, call, captureContent) {
+    return tracer.startSpan(`${GEN_AI_OPERATION_NAME_VALUE_EXECUTE_TOOL} ${call.name}`, {
+        kind: SpanKind.INTERNAL,
+        attributes: {
+            [ATTR_GEN_AI_OPERATION_NAME]: GEN_AI_OPERATION_NAME_VALUE_EXECUTE_TOOL,
+            [ATTR_GEN_AI_TOOL_NAME]: call.name,
+            [ATTR_GEN_AI_TOOL_CALL_ID]: call.id,
+            [ATTR_GEN_AI_TOOL_TYPE]: "function",
+            ...(captureContent
+                ? { [ATTR_GEN_AI_TOOL_CALL_ARGUMENTS]: json(call.arguments) }
+                : {}),
+        },
+    }, trace.setSpan(ROOT_CONTEXT, segment.span));
+}
+/** Mark a span failed, with the reason as its error type. */
+function fail(span, reason) {
+    span.setAttribute(ATTR_ERROR_TYPE, reason);
+    span.setStatus({ code: SpanStatusCode.ERROR, message: reason });
+    return span;
+}
+/** Run a hook's tracing so that it never fails the run: pi blocks a tool call whose beforeTool throws. */
+async function safely(work) {
+    try {
+        await work();
+    }
+    catch (error) {
+        diag.error("que-pasa: tracing failed", error);
+    }
+    return undefined;
+}
+function parentOf(span) {
+    return {
+        traceId: span.traceId,
+        spanId: span.spanId,
+        traceFlags: span.traceFlags,
+    };
+}
+const json = (value) => JSON.stringify(value);
+function textOf(content) {
+    return typeof content === "string"
+        ? content
+        : content
+            .map((block) => block.type === "text" ? block.text : `[${block.mimeType}]`)
+            .join("");
+}
+/** A pi-ai message as the GenAI conventions write it. */
+function toGenAi(message) {
+    switch (message.role) {
+        case "user":
+            return {
+                role: "user",
+                parts: [{ type: "text", content: textOf(message.content) }],
+            };
+        case "assistant":
+            return {
+                role: "assistant",
+                parts: message.content.map((block) => {
+                    if (block.type === "text")
+                        return { type: "text", content: block.text };
+                    if (block.type === "thinking")
+                        return { type: "reasoning", content: block.thinking };
+                    return {
+                        type: "tool_call",
+                        id: block.id,
+                        name: block.name,
+                        arguments: block.arguments,
+                    };
+                }),
+                finish_reason: message.stopReason,
+            };
+        case "toolResult":
+            return {
+                role: "tool",
+                parts: [
+                    {
+                        type: "tool_call_response",
+                        id: message.toolCallId,
+                        response: textOf(message.content),
+                    },
+                ],
+            };
+        default:
+            return { role: message.role, parts: [] };
+    }
+}

package/dist/loop/transcript.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from "@earendil-works/chord/context";
+import type { Message } from "@earendil-works/pi-ai";
+import type { Cursor, EntryQuery, EntryRecord, Page } from "@earendil-works/pi-durable";
+/** A reader of one conversation's raw history: a conversation, or a hook's api. */
+type Entries = {
+    entries(query: Omit<EntryQuery, "conversationId">, limit: number, cursor: Cursor | undefined, context: Context): Promise<Page<EntryRecord, Cursor>>;
+};
+/** The conversation's messages, oldest first, without the system entries: every page of its raw history. */
+export declare function messagesOf(reader: Entries, context: Context): Promise<Message[]>;
+/** The text of a user message. */
+export declare function userText(message: Message): string | undefined;
+/** The text of the last assistant message: the answer of an agent with no output. */
+export declare function answerOf(messages: readonly Message[]): string;
+/** The details of the last successful result of the tool `name`: where the submit tool keeps the run's output. */
+export declare function resultOf(messages: readonly Message[], name: string): {
+    value: unknown;
+} | undefined;
+export {};

package/dist/loop/transcript.js

@@ -0,0 +1,43 @@
+/** The conversation's messages, oldest first, without the system entries: every page of its raw history. */
+export async function messagesOf(reader, context) {
+    const messages = [];
+    let cursor;
+    do {
+        const page = await reader.entries({ order: "ascending" }, 100, cursor, context);
+        for (const entry of page.items) {
+            for (const message of entry.model ?? []) {
+                if (message.role !== "system")
+                    messages.push(message);
+            }
+        }
+        cursor = page.next;
+    } while (cursor !== undefined);
+    return messages;
+}
+/** The text of a user message. */
+export function userText(message) {
+    if (message.role !== "user")
+        return undefined;
+    const { content } = message;
+    return typeof content === "string"
+        ? content
+        : content
+            .flatMap((block) => (block.type === "text" ? [block.text] : []))
+            .join("");
+}
+/** The text of the last assistant message: the answer of an agent with no output. */
+export function answerOf(messages) {
+    const answer = messages.findLast((message) => message.role === "assistant");
+    if (!answer || answer.role !== "assistant")
+        return "";
+    return answer.content
+        .flatMap((block) => (block.type === "text" ? [block.text] : []))
+        .join("");
+}
+/** The details of the last successful result of the tool `name`: where the submit tool keeps the run's output. */
+export function resultOf(messages, name) {
+    const result = messages.findLast((message) => message.role === "toolResult" &&
+        message.toolName === name &&
+        !message.isError);
+    return result?.role === "toolResult" ? { value: result.details } : undefined;
+}

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "@mku1tra/que-pasa",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "An agent harness on pi-durable: define agents and tools with define/, and run them durably and traced with loop/.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/matta-kelly/que-pasa.git"
+  },
+  "type": "module",
+  "packageManager": "npm@11.21.0",
+  "engines": {
+    "node": ">=22.18"
+  },
+  "exports": {
+    "./define": {
+      "types": "./dist/define/index.d.ts",
+      "default": "./dist/define/index.js"
+    },
+    "./loop": {
+      "types": "./dist/loop/index.d.ts",
+      "default": "./dist/loop/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json"
+  },
+  "dependencies": {
+    "@earendil-works/chord": "1.5.0",
+    "@earendil-works/pi-ai": "1.5.0",
+    "@earendil-works/pi-durable": "1.5.0",
+    "@opentelemetry/api": "1.10.0",
+    "@opentelemetry/semantic-conventions": "1.43.0"
+  },
+  "peerDependencies": {
+    "zod": "^4.6.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "10.0.1",
+    "@mku1tra/basis": "^0.30.0",
+    "@mku1tra/it": "^0.9.0",
+    "@opentelemetry/context-async-hooks": "3.0.0",
+    "@opentelemetry/sdk-trace": "3.0.0",
+    "@types/node": "22.20.5",
+    "eslint": "10.12.0",
+    "eslint-plugin-sonarjs": "4.2.2",
+    "globals": "17.13.0",
+    "jiti": "2.7.0",
+    "prettier": "3.9.10",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.71.2",
+    "vite": "8.3.4",
+    "vitest": "5.0.4",
+    "zod": "4.6.7"
+  }
+}