@chrok/dsh-braid 0.0.0-stage → 0.3.2

package/dist/panel-contract.js

@@ -0,0 +1,29 @@
+/** One descriptor table shared by Host registration and Client Remote mounting. */
+export const PANEL_PACKAGE = "@chrok/dsh-braid";
+function parseRequest(value, method) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Invalid Braid panel request");
+    const r = value;
+    const id = (key) => typeof r[key] === "string" && r[key].length > 0 && r[key].length <= 1024;
+    if (!id("sessionId") || (r.jobId !== undefined && !id("jobId")))
+        throw new Error("Invalid session or job ID");
+    if (r.createdBefore !== undefined && (!Number.isSafeInteger(r.createdBefore) || Number(r.createdBefore) < 0))
+        throw new Error("Invalid call timestamp");
+    if (method !== "watch" && !id("jobId"))
+        throw new Error("A job ID is required");
+    if (method === "control" && (!["cancel", "resume"].includes(String(r.action)) || !Number.isSafeInteger(r.revision) || Number(r.revision) < 0 ||
+        !Array.isArray(r.executionIds) || r.executionIds.length > 10000 || r.executionIds.some(v => typeof v !== "string" || !v || v.length > 1024)))
+        throw new Error("Invalid Braid control request");
+    if (method === "detail" && (!id("executionId") || !Number.isSafeInteger(r.offset) || Number(r.offset) < 0))
+        throw new Error("Invalid execution or offset");
+    return value;
+}
+export const panelDescriptors = ["watch", "control", "detail"].map(method => ({
+    id: `${PANEL_PACKAGE}#braidPanel/${method}`, service: "braidPanel", namespace: "braidPanel", method,
+    invocation: { kind: "direct" },
+    parameters: [{ name: "request", wire: "request", source: "json", codec: {
+                mode: "strict", typeSymbol: `${PANEL_PACKAGE}/${method}Request`, create: () => ({ parse: value => parseRequest(value, method) }),
+            } }],
+    result: { mode: "src-json" },
+    ...(method === "watch" ? { mode: "stream", cancellation: { parameter: "signal" } } : {}),
+}));

package/dist/panel-types.d.ts

@@ -0,0 +1,100 @@
+/** Browser-safe, bounded projections. Prompts and provider messages never enter the panel stream. */
+export interface PanelRequest {
+    sessionId: string;
+    jobId?: string;
+    createdBefore?: number;
+}
+export interface ControlRequest extends PanelRequest {
+    jobId: string;
+    action: "cancel" | "resume";
+    revision: number;
+    executionIds: string[];
+}
+export interface DetailRequest extends PanelRequest {
+    jobId: string;
+    executionId: string;
+    offset: number;
+}
+export interface PanelRow {
+    jobId: string;
+    handle: string;
+    goal: string;
+    status: string;
+    createdAt: number;
+}
+export interface PanelExecution {
+    id: string;
+    executionId: string;
+    status: string;
+    type: string;
+    revision: number;
+    iteration?: number;
+    loopId?: string;
+    latencyMs?: number;
+    progress?: {
+        contextTokens: number;
+        contextWindow?: number;
+        contextSource: string;
+        toolCalls: number;
+        toolRounds: number;
+        phase: string;
+    };
+}
+export interface PanelJob extends PanelRow {
+    revision: number;
+    phase: string;
+    error?: string;
+    nodes: {
+        id: string;
+        type: string;
+        status: string;
+    }[];
+    edges: {
+        from: string;
+        to: string;
+        choice?: string;
+        feedback?: string;
+        executionId?: string;
+    }[];
+    loops: {
+        id: string;
+        entry: string;
+        maxIterations: number;
+    }[];
+    executions: PanelExecution[];
+    pausedExecutionIds: string[];
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens: number;
+        cacheWriteTokens: number;
+    };
+    events: {
+        sequence: number;
+        timestamp: number;
+        type: string;
+        executionId?: string;
+        nodeId?: string;
+        message: string;
+    }[];
+}
+export interface PanelFrame {
+    rows: PanelRow[];
+    job: PanelJob | null;
+}
+export interface PanelDetail {
+    executionId: string;
+    status: string;
+    output: string;
+    offset: number;
+    next: number;
+    total: number;
+    decision?: string;
+    error?: string;
+    workspace?: string;
+}
+export interface PanelApi {
+    watch(request: PanelRequest, signal: AbortSignal): AsyncIterable<PanelFrame>;
+    control(request: ControlRequest): Promise<PanelFrame>;
+    detail(request: DetailRequest): Promise<PanelDetail>;
+}

package/dist/panel-types.js

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

package/dist/panel.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from "@deepseek-ai/cordis";
+import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import type { BraidJobs, JobSnapshot } from "./jobs.js";
+import type { ControlRequest, DetailRequest, PanelDetail, PanelFrame, PanelJob, PanelRequest } from "./panel-types.js";
+export declare function panelJob(job: JobSnapshot): PanelJob;
+/** Session managers are borrowed; viewing a panel never creates an Agent or starts model work. */
+export declare class BraidPanel extends TypertRemoteService {
+    private readonly find;
+    private readonly subscribe;
+    constructor(ctx: Context, find: (sessionId: string) => BraidJobs | undefined, subscribe: (listener: () => void) => () => void);
+    snapshot(request: PanelRequest): PanelFrame;
+    watch(request: PanelRequest, signal: AbortSignal): AsyncIterable<PanelFrame>;
+    control(request: ControlRequest): PanelFrame;
+    detail(request: DetailRequest): PanelDetail;
+    private failure;
+}

package/dist/panel.js

@@ -0,0 +1,169 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { Remote, RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { PANEL_PACKAGE, panelDescriptors } from "./panel-contract.js";
+const clip = (text, limit = 2000) => text.length > limit ? text.slice(0, limit) + "…" : text;
+export function panelJob(job) {
+    const state = job.execution;
+    return {
+        jobId: job.jobId, handle: job.handle, goal: clip(job.goal), status: job.status, createdAt: job.createdAt,
+        revision: state.revision, phase: state.status,
+        ...(job.error || state.error ? { error: clip(job.error ?? state.error.message) } : {}),
+        nodes: state.graph.nodes.map(node => ({ id: node.id, type: node.type, status: state.nodes[node.id]?.status ?? "pending" })),
+        edges: state.graph.edges.map(edge => ({ ...edge })), loops: [...state.graph.loops ?? []],
+        executions: Object.values(state.executions).map(e => ({
+            id: e.id, executionId: e.executionId, status: e.status, type: e.node.type, revision: e.revision,
+            ...(e.iteration === undefined ? {} : { iteration: e.iteration }),
+            ...(e.loopId === undefined ? {} : { loopId: e.loopId }),
+            ...(e.latencyMs === undefined ? {} : { latencyMs: e.latencyMs }),
+            ...(job.progress[e.executionId] ? { progress: job.progress[e.executionId] } : {}),
+        })),
+        pausedExecutionIds: [...state.pausedExecutionIds],
+        usage: { inputTokens: job.usage.inputTokens ?? 0, outputTokens: job.usage.outputTokens ?? 0,
+            cacheReadTokens: job.usage.cacheReadTokens ?? 0, cacheWriteTokens: job.usage.cacheWriteTokens ?? 0 },
+        events: job.events.map(e => ({ sequence: e.sequence, timestamp: e.timestamp, type: e.type,
+            ...(e.executionId ? { executionId: e.executionId } : {}), ...("nodeId" in e ? { nodeId: e.nodeId } : {}),
+            message: clip("error" in e ? e.error.message : e.type === "handoff" ? `${e.from} → ${e.to}` : e.type === "edge_created" ? `${e.from} → ${e.to}` : e.type.replaceAll("_", " "), 500),
+        })),
+    };
+}
+/** Session managers are borrowed; viewing a panel never creates an Agent or starts model work. */
+let BraidPanel = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _watch_decorators;
+    let _control_decorators;
+    let _detail_decorators;
+    return class BraidPanel extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _watch_decorators = [Remote({ mode: "stream" })];
+            _control_decorators = [Remote];
+            _detail_decorators = [Remote];
+            __esDecorate(this, null, _watch_decorators, { kind: "method", name: "watch", static: false, private: false, access: { has: obj => "watch" in obj, get: obj => obj.watch }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _control_decorators, { kind: "method", name: "control", static: false, private: false, access: { has: obj => "control" in obj, get: obj => obj.control }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _detail_decorators, { kind: "method", name: "detail", static: false, private: false, access: { has: obj => "detail" in obj, get: obj => obj.detail }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        find = __runInitializers(this, _instanceExtraInitializers);
+        subscribe;
+        constructor(ctx, find, subscribe) {
+            super(ctx, "braidPanel");
+            this.find = find;
+            this.subscribe = subscribe;
+            ctx.typert.register({ package: PANEL_PACKAGE, face: "host", schemas: [], model: { services: [], events: [], objects: [] }, invocations: panelDescriptors });
+        }
+        snapshot(request) {
+            const jobs = this.find(request.sessionId);
+            const rows = jobs?.list().map(row => ({ ...row, goal: clip(row.goal) })) ?? [];
+            // Old tool cards can carry short handles. Fence them by the call's timestamp
+            // so a Host/plugin restart cannot redirect an old card to a reused handle.
+            const selected = request.jobId ? rows.find(row => (row.jobId === request.jobId || row.handle === request.jobId)
+                && (request.createdBefore === undefined || row.createdAt <= request.createdBefore)) : rows[0];
+            if (request.jobId && !selected)
+                throw new Error("Braid job is no longer available in this session");
+            const id = selected?.jobId;
+            return { rows, job: id && jobs ? panelJob(jobs.get(id)) : null };
+        }
+        async *watch(request, signal) {
+            let dirty = true, wake;
+            const changed = () => { dirty = true; wake?.(); };
+            const off = this.subscribe(changed);
+            signal.addEventListener("abort", changed, { once: true });
+            try {
+                while (!signal.aborted) {
+                    if (!dirty)
+                        await new Promise(resolve => { wake = resolve; });
+                    wake = undefined;
+                    if (signal.aborted)
+                        break;
+                    dirty = false;
+                    try {
+                        yield this.snapshot(request);
+                    }
+                    catch (error) {
+                        throw this.failure(request, error);
+                    }
+                    // Coalesce token bursts; cancellation also wakes this delay.
+                    await new Promise(resolve => {
+                        const done = () => { clearTimeout(timer); signal.removeEventListener("abort", done); resolve(); };
+                        const timer = setTimeout(done, 150);
+                        signal.addEventListener("abort", done, { once: true });
+                        if (signal.aborted)
+                            done();
+                    });
+                }
+            }
+            finally {
+                off();
+                signal.removeEventListener("abort", changed);
+            }
+        }
+        control(request) {
+            try {
+                this.snapshot(request);
+                const jobs = this.find(request.sessionId);
+                if (request.action === "resume")
+                    jobs.resume(request.jobId, request.executionIds, request.revision);
+                else
+                    jobs.cancel(request.jobId);
+                return this.snapshot(request);
+            }
+            catch (error) {
+                throw this.failure(request, error);
+            }
+        }
+        detail(request) {
+            try {
+                this.snapshot(request);
+                const node = this.find(request.sessionId).getNode(request.jobId, undefined, request.executionId);
+                const output = node.output ?? "";
+                const offset = Math.min(request.offset, output.length), next = Math.min(offset + 32768, output.length);
+                return { executionId: request.executionId, status: node.status, output: output.slice(offset, next), offset, next, total: output.length,
+                    ...(node.decision === undefined ? {} : { decision: clip(node.decision) }),
+                    ...(node.error ? { error: clip(node.error.message) } : {}),
+                    ...(node.workspace ? { workspace: clip(JSON.stringify(node.workspace, null, 2), 8000) } : {}),
+                };
+            }
+            catch (error) {
+                throw this.failure(request, error);
+            }
+        }
+        failure(request, error) {
+            return new RemoteError("braid/panel", error instanceof Error ? error.message : String(error), { sessionId: request.sessionId });
+        }
+    };
+})();
+export { BraidPanel };

package/dist/runner.d.ts

@@ -0,0 +1,27 @@
+import { type LlmRuntime, type TokenUsage } from "@deepseek-ai/dsh-llm";
+import { type ModelRunner } from "@chrok/braid";
+export interface NodeProgress {
+    nodeId: string;
+    executionId: string;
+    contextTokens: number;
+    contextWindow?: number;
+    contextSource: "reported" | "estimate";
+    toolCalls: number;
+    toolRounds: number;
+    phase: "model" | "tool";
+}
+export interface RunnerOptions {
+    cwd: string;
+    maxToolRounds?: number;
+    maxToolCalls?: number;
+    onUsage?: (usage: TokenUsage) => void;
+    onProgress?: (progress: NodeProgress) => void;
+}
+export declare function validateBudgets(options: {
+    maxToolRounds?: number | undefined;
+    maxToolCalls?: number | undefined;
+}): void;
+/** Fresh, private model contexts. DSH owns provider routing and credentials. */
+export type DshLlm = Pick<LlmRuntime, "stream"> & Partial<Pick<LlmRuntime, "resolveModelInfo">>;
+export declare function createDshRunner(llm: DshLlm, options: RunnerOptions): ModelRunner;
+export declare function sumUsage(reports: readonly TokenUsage[]): TokenUsage;

package/dist/runner.js

@@ -0,0 +1,176 @@
+import { resolve } from "node:path";
+import { BlockAssembler, createToolResultMessage, } from "@deepseek-ai/dsh-llm";
+import { formatBudgetReminder, gitToolDefinition, finishMergeToolDefinition, mergeInstructions, parseGitToolArguments, parseFinishMergeArguments, } from "@chrok/braid";
+import { createWorkerTools } from "./worker-tools.js";
+export function validateBudgets(options) {
+    for (const [key, value] of Object.entries(options)) {
+        if (value !== undefined && value !== Infinity && (!Number.isSafeInteger(value) || value < 1))
+            throw new Error(`${key} must be a positive safe integer or Infinity`);
+    }
+}
+export function createDshRunner(llm, options) {
+    validateBudgets({ maxToolRounds: options.maxToolRounds, maxToolCalls: options.maxToolCalls });
+    return async (request) => {
+        const route = request.model;
+        const slash = route?.indexOf("/") ?? -1;
+        if (!route || slash < 1 || slash === route.length - 1)
+            throw new Error("Choose a DSH provider/model, or set node.model to an exact provider/model-id");
+        const provider = route.slice(0, slash), model = route.slice(slash + 1);
+        const modelInfo = await llm.resolveModelInfo?.(provider, model, request.signal);
+        const contextWindow = modelInfo?.context?.contextWindow;
+        request.signal.throwIfAborted();
+        const workspace = request.workspace ?? {
+            nodeId: request.node.id, mode: "read-only",
+            workingDirectory: resolve(options.cwd), state: "ready",
+        };
+        const files = await createWorkerTools(request, workspace);
+        const tools = files.map(({ name, description, parameters }) => ({ name, description, parameters: JSON.parse(JSON.stringify(parameters)) }));
+        const integrating = request.node.type === "merge" || request.node.type === "integrate";
+        if (request.git)
+            tools.push(gitToolDefinition(integrating));
+        if (request.merge)
+            tools.push(finishMergeToolDefinition(request.merge.sources.map(source => source.executionId)));
+        if (request.node.type === "decision")
+            tools.push({
+                name: "decide", description: "Select exactly one declared choice before answering.",
+                parameters: { type: "object", properties: { choice: { type: "string", enum: request.node.choices } }, required: ["choice"], additionalProperties: false },
+            });
+        const messages = [{ role: "user", content: [{ type: "text", text: JSON.stringify({
+                            goal: request.goal, nodeId: request.node.id, execution: request.execution,
+                            prompt: request.node.prompt, predecessors: request.predecessors, workspace,
+                            ...(request.merge ? { mergeSources: request.merge.sources, sourceCheckoutStatus: request.merge.sourceStatus } : {}),
+                        }) }] }];
+        const system = "You are an isolated Braid worker. Complete only the assigned node. " +
+            "Use read, ls, grep, and find to inspect files. Only writable Git workspaces have write, edit, and shell tools. " +
+            "Use your assigned workingDirectory. Never write outside it; integrate alone may edit sourceRoot. " +
+            "Shell tools have host permissions, not a sandbox. Do not change shared Git refs, branches, configuration, hooks, or worktree registrations. " +
+            "Do not launch recursive agents, daemons, or background servers. Use execution-specific temporary resources. " +
+            "Checkpoints exclude ignored new dependencies, caches, and build outputs. Run tests for your changes. " +
+            "Parent transcript, skills, extension tools, and MCP tools are not inherited. " +
+            mergeInstructions(request) +
+            (request.node.type === "decision" ? "Call decide exactly once, then answer. " : "") +
+            "Return a nonempty natural-language result.";
+        let toolRounds = 0, toolCalls = 0, decided = false;
+        let contextTokens = 0;
+        let contextSource = "estimate";
+        const reports = [];
+        const output = [];
+        const progress = (phase) => {
+            try {
+                options.onProgress?.({ nodeId: request.node.id, executionId: request.execution.executionId, contextTokens, ...(contextWindow === undefined ? {} : { contextWindow }), contextSource, toolCalls, toolRounds, phase });
+            }
+            catch { /* Observers cannot fail a worker. */ }
+        };
+        while (true) {
+            request.signal.throwIfAborted();
+            const budgets = [
+                ...(options.maxToolRounds === undefined ? [] : [`Tool round budget: ${toolRounds}/${options.maxToolRounds} used.`]),
+                ...(options.maxToolCalls === undefined ? [] : [`Tool call budget: ${toolCalls}/${options.maxToolCalls} used; rejected requests count.`]),
+                "Reserve budget for decide or finish_merge. At zero remaining, return your final answer without further tools.",
+            ];
+            const activeTools = tools.filter(tool => !decided || tool.name !== "decide");
+            const prompt = system + formatBudgetReminder(request, budgets);
+            contextTokens = Math.ceil(JSON.stringify({ messages, system: prompt, tools: activeTools }).length / 4);
+            contextSource = "estimate";
+            progress("model");
+            const assembler = new BlockAssembler();
+            let finished = false;
+            try {
+                for await (const chunk of llm.stream({ provider, model, messages, system: prompt, tools: activeTools, signal: request.signal })) {
+                    request.signal.throwIfAborted();
+                    assembler.push(chunk);
+                    if (chunk.type === "finish")
+                        finished = true;
+                }
+            }
+            finally {
+                if (assembler.usage) {
+                    const usage = structuredClone(assembler.usage);
+                    reports.push(usage);
+                    options.onUsage?.(usage);
+                    contextTokens = usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
+                    contextSource = "reported";
+                    progress("model");
+                }
+            }
+            request.signal.throwIfAborted();
+            const finish = assembler.finish;
+            if (!finished)
+                throw new Error("DSH model stream ended without a finish event");
+            if (finish.kind !== "stop" && finish.kind !== "tool-calls")
+                throw new Error("failure" in finish ? finish.failure.message : `DSH model ended with ${finish.kind}`);
+            const response = assembler.message({ provider, model, ...(assembler.replayState ? { replayState: assembler.replayState } : {}) });
+            output.push(...response.content.flatMap(block => block.type === "text" ? [block.text] : []));
+            const calls = response.content.filter(block => block.type === "tool-call");
+            if (!calls.length) {
+                if (finish.kind === "tool-calls")
+                    throw new Error("DSH requested tool use without tool calls");
+                break;
+            }
+            if (finish.kind !== "tool-calls")
+                throw new Error("DSH returned tool calls with an invalid finish reason");
+            toolRounds++;
+            toolCalls += calls.length;
+            progress("tool");
+            if (toolRounds > (options.maxToolRounds ?? Infinity) || toolCalls > (options.maxToolCalls ?? Infinity))
+                throw new Error("Braid node exceeded its tool budget");
+            messages.push(response);
+            for (const call of calls) {
+                request.signal.throwIfAborted();
+                let text, isError = false;
+                try {
+                    const args = JSON.parse(call.arguments);
+                    if (call.name === "decide" && request.decide) {
+                        if (!args || typeof args !== "object" || Array.isArray(args) || Object.keys(args).length !== 1 || !("choice" in args) || typeof args.choice !== "string")
+                            throw new Error("decide requires exactly one string argument: choice");
+                        request.decide(args.choice);
+                        decided = true;
+                        text = JSON.stringify({ choice: args.choice });
+                    }
+                    else if (call.name === "git" && request.git) {
+                        const parsed = parseGitToolArguments(args, integrating);
+                        const result = await request.git(parsed.args, parsed.input);
+                        text = JSON.stringify(result);
+                        isError = result.exitCode !== 0;
+                    }
+                    else if (call.name === "finish_merge" && request.merge) {
+                        await request.merge.finish(parseFinishMergeArguments(args, request.merge.sources.map(source => source.executionId)));
+                        text = "Merge dispositions recorded. Return your final answer.";
+                    }
+                    else {
+                        const tool = files.find(tool => tool.name === call.name);
+                        if (!tool)
+                            throw new Error(`Unavailable tool '${call.name}'. Available: ${activeTools.map(tool => tool.name).join(", ")}`);
+                        const invoke = () => tool.execute(args);
+                        text = tool.writes && request.withWorkspaceWrite ? await request.withWorkspaceWrite(invoke) : await invoke();
+                    }
+                }
+                catch (error) {
+                    request.signal.throwIfAborted();
+                    // Invalid or duplicate decisions are terminal, matching core's exactly-once contract.
+                    if (call.name === "decide" && request.decide)
+                        throw error;
+                    isError = true;
+                    text = error instanceof Error ? error.message : String(error);
+                }
+                messages.push(createToolResultMessage({ callId: call.id, content: [{ type: "text", text }], isError }));
+            }
+        }
+        const text = output.filter(part => part.trim()).join("\n\n");
+        if (!text.trim())
+            throw new Error("DSH model returned no textual output");
+        const usage = sumUsage(reports);
+        return { output: text, model: route, usage: {
+                inputTokens: usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0), outputTokens: usage.outputTokens,
+            } };
+    };
+}
+export function sumUsage(reports) {
+    const total = { inputTokens: 0, outputTokens: 0 };
+    for (const report of reports)
+        for (const key of ["inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens", "reasoningTokens"])
+            if (report[key] !== undefined)
+                total[key] = (total[key] ?? 0) + report[key];
+    total.totalTokens = total.inputTokens + total.outputTokens + (total.cacheReadTokens ?? 0) + (total.cacheWriteTokens ?? 0);
+    return total;
+}

package/dist/schema.d.ts

@@ -0,0 +1,64 @@
+export declare const nodeParameters: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+    type: import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<string>[]>;
+    prompt: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+        template: import("@sinclair/typebox").TString;
+        variables: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>;
+    }>]>>;
+    choices: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    workspace: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<string>[]>>;
+    model: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    notifyOnCompletion: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    pauseAfter: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    requireSuccess: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+export declare const updateEdgeParameters: import("@sinclair/typebox").TObject<{
+    executionId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    from: import("@sinclair/typebox").TString;
+    to: import("@sinclair/typebox").TString;
+    choice: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    feedback: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const loopParameters: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+    entry: import("@sinclair/typebox").TString;
+    maxIterations: import("@sinclair/typebox").TInteger;
+}>;
+export declare const braidParameters: import("@sinclair/typebox").TObject<{
+    goal: import("@sinclair/typebox").TString;
+    nodes: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        type: import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<string>[]>;
+        prompt: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+            template: import("@sinclair/typebox").TString;
+            variables: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>;
+        }>]>>;
+        choices: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+        workspace: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<string>[]>>;
+        model: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        notifyOnCompletion: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        pauseAfter: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        requireSuccess: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    }>>;
+    edges: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        from: import("@sinclair/typebox").TString;
+        to: import("@sinclair/typebox").TString;
+        choice: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        feedback: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>>;
+    promptTemplates: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    loops: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        entry: import("@sinclair/typebox").TString;
+        maxIterations: import("@sinclair/typebox").TInteger;
+    }>>>;
+    options: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        maxConcurrency: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        maxExecutions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        nodeTimeoutMs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        graphTimeoutMs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        maxToolRounds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+        maxToolCalls: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
+    }>>;
+}>;
+export declare const BRAID_USAGE_GUIDANCE: string;