@deepstrike/wasm 0.1.6

package/dist/harness/index.d.ts

@@ -0,0 +1,74 @@
+import type { Agent } from "../agent.js";
+export interface Criterion {
+    text: string;
+    required: boolean;
+    weight?: number;
+}
+export interface CriterionResult {
+    criterion: string;
+    passed: boolean;
+    score: number;
+    feedback: string;
+}
+export interface HarnessRequest {
+    goal: string;
+    criteria?: Criterion[];
+    extensions?: Record<string, unknown>;
+}
+export interface HarnessOutcome {
+    result: string;
+    passed: boolean;
+    iterations: number;
+    totalTokens: number;
+    status: string;
+    overallScore?: number;
+    feedback?: string;
+    details?: CriterionResult[];
+}
+export interface Verdict {
+    passed: boolean;
+    overallScore: number;
+    feedback: string;
+    details: CriterionResult[];
+}
+export type HarnessEvent = {
+    type: "token";
+    text: string;
+} | {
+    type: "tool_call";
+    id: string;
+    name: string;
+} | {
+    type: "tool_result";
+    callId: string;
+    content: string;
+    isError: boolean;
+} | {
+    type: "supervising";
+} | {
+    type: "revising";
+    verdict: Verdict;
+} | {
+    type: "done";
+    verdict: Verdict;
+    iterations: number;
+    totalTokens: number;
+    status: string;
+} | {
+    type: "max_attempts_reached";
+};
+export declare class SinglePassHarness {
+    private agent;
+    constructor(agent: Agent);
+    run(request: HarnessRequest): Promise<HarnessOutcome>;
+}
+export interface HarnessLoopOptions {
+    maxAttempts?: number;
+}
+export declare class HarnessLoop {
+    private agent;
+    private evalProvider;
+    private maxAttempts;
+    constructor(agent: Agent, evalProvider: import("../types.js").LLMProvider, options?: HarnessLoopOptions);
+    runStreaming(request: HarnessRequest): AsyncIterable<HarnessEvent>;
+}

package/dist/harness/index.js

@@ -0,0 +1,91 @@
+async function runOnce(agent, goal, req) {
+    let text = "";
+    let done;
+    for await (const evt of agent.runStreaming(goal, (req.criteria ?? []).map(c => c.text), req.extensions)) {
+        if (evt.type === "text_delta")
+            text += evt.delta;
+        else if (evt.type === "done")
+            done = evt;
+    }
+    return { result: text, passed: false, iterations: done?.iterations ?? 0, totalTokens: done?.totalTokens ?? 0, status: done?.status ?? "error" };
+}
+export class SinglePassHarness {
+    agent;
+    constructor(agent) {
+        this.agent = agent;
+    }
+    async run(request) {
+        return { ...await runOnce(this.agent, request.goal, request), passed: true };
+    }
+}
+export class HarnessLoop {
+    agent;
+    evalProvider;
+    maxAttempts;
+    constructor(agent, evalProvider, options = {}) {
+        this.agent = agent;
+        this.evalProvider = evalProvider;
+        this.maxAttempts = options.maxAttempts ?? 3;
+    }
+    async *runStreaming(request) {
+        const kernel = await import("@deepstrike/wasm-kernel");
+        const pipeline = new kernel.EvalPipeline({ extractSkillOnPass: true });
+        const criteria = request.criteria ?? [];
+        let currentGoal = request.goal;
+        let lastIterations = 0;
+        let lastTotalTokens = 0;
+        let lastStatus = "error";
+        let lastResult = "";
+        for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
+            for await (const evt of this.agent.runStreaming(currentGoal, criteria.map(c => c.text), request.extensions)) {
+                if (evt.type === "text_delta") {
+                    lastResult += evt.delta;
+                    yield { type: "token", text: evt.delta };
+                }
+                else if (evt.type === "tool_call") {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const tc = evt;
+                    yield { type: "tool_call", id: tc.id, name: tc.name };
+                }
+                else if (evt.type === "tool_result") {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const tr = evt;
+                    yield { type: "tool_result", callId: tr.callId, content: tr.content, isError: tr.isError };
+                }
+                else if (evt.type === "done") {
+                    const d = evt;
+                    lastIterations = d.iterations;
+                    lastTotalTokens = d.totalTokens;
+                    lastStatus = d.status;
+                }
+            }
+            yield { type: "supervising" };
+            const evalAction = pipeline.feedOutcome(request.goal, criteria, lastResult, attempt);
+            if (evalAction.kind !== "evaluate")
+                break;
+            let evalText = "";
+            for await (const evt of this.evalProvider.stream((evalAction.messages ?? []), [], undefined)) {
+                if (evt.type === "text_delta")
+                    evalText += evt.delta;
+            }
+            const doneAction = pipeline.feedEvalResult(evalText);
+            if (doneAction.kind !== "done")
+                break;
+            const verdict = {
+                passed: doneAction.passed ?? false,
+                overallScore: doneAction.overallScore ?? 0,
+                feedback: doneAction.feedback ?? "",
+                details: doneAction.details ?? [],
+            };
+            if (verdict.passed) {
+                yield { type: "done", verdict, iterations: lastIterations, totalTokens: lastTotalTokens, status: lastStatus };
+                return;
+            }
+            yield { type: "revising", verdict };
+            currentGoal = `${request.goal}\n\n[Attempt ${attempt} feedback: ${verdict.feedback}]`;
+            lastResult = "";
+            pipeline.reset();
+        }
+        yield { type: "max_attempts_reached" };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { Agent } from "./agent.js";
+export type { AgentOptions, SkillMetadata } from "./agent.js";
+export { Governance } from "./governance.js";
+export type { GovernanceVerdict } from "./governance.js";
+export { AnthropicProvider } from "./providers/anthropic.js";
+export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiProvider } from "./providers/openai.js";
+export { tool, executeTools } from "./tools/index.js";
+export type { RegisteredTool } from "./tools/index.js";
+export { WorkingMemory } from "./memory/index.js";
+export type { DreamStore, DreamResult, SessionData, SessionMessage, MemoryEntry, CurationResult, CurationStats, } from "./memory/index.js";
+export type { KnowledgeSource } from "./knowledge/index.js";
+export { SinglePassHarness, HarnessLoop } from "./harness/index.js";
+export type { HarnessRequest, HarnessOutcome, HarnessLoopOptions } from "./harness/index.js";
+export { ScheduledPrompt } from "./signals/index.js";
+export type { RuntimeSignal, SignalSource } from "./signals/index.js";
+export { PermissionManager, PermissionMode } from "./safety/index.js";
+export type { PermissionDecision } from "./safety/index.js";
+export type { Message, ToolCall, ToolResult, ToolSchema, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, } from "./types.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+export { Agent } from "./agent.js";
+export { Governance } from "./governance.js";
+export { AnthropicProvider } from "./providers/anthropic.js";
+export { OpenAIProvider, QwenProvider, DeepSeekProvider, MiniMaxProvider, KimiProvider } from "./providers/openai.js";
+export { tool, executeTools } from "./tools/index.js";
+export { WorkingMemory } from "./memory/index.js";
+export { SinglePassHarness, HarnessLoop } from "./harness/index.js";
+export { ScheduledPrompt } from "./signals/index.js";
+export { PermissionManager, PermissionMode } from "./safety/index.js";

package/dist/knowledge/index.d.ts

@@ -0,0 +1,5 @@
+export interface KnowledgeSource {
+    retrieve(goal: string, topK?: number): Promise<string[]>;
+    /** One-time warmup called before the first run (load index, open connection, etc.). */
+    init(): Promise<void>;
+}

package/dist/knowledge/index.js

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

package/dist/memory/index.d.ts

@@ -0,0 +1,56 @@
+export declare class WorkingMemory {
+    private store;
+    set(key: string, value: unknown): void;
+    get<T = unknown>(key: string, defaultValue?: T): T | undefined;
+    delete(key: string): void;
+    clear(): void;
+    has(key: string): boolean;
+}
+export interface SessionMessage {
+    role: "user" | "assistant" | "tool";
+    content: string;
+    tokenCount?: number;
+    toolCalls?: Array<{
+        id: string;
+        name: string;
+        arguments: string;
+    }>;
+}
+export interface SessionData {
+    sessionId: string;
+    agentId: string;
+    messages: SessionMessage[];
+    metadata: unknown;
+    createdAtMs: number;
+    updatedAtMs: number;
+}
+export interface MemoryEntry {
+    text: string;
+    score: number;
+    metadata: unknown;
+}
+export interface CurationStats {
+    insightsProcessed: number;
+    duplicatesRemoved: number;
+    conflictsResolved: number;
+    entriesAdded: number;
+}
+export interface CurationResult {
+    toAdd: MemoryEntry[];
+    toRemoveIndices: number[];
+    stats: CurationStats;
+}
+export interface DreamResult {
+    sessionsProcessed: number;
+    insightsExtracted: number;
+    entriesAdded: number;
+    entriesRemoved: number;
+}
+export interface DreamStore {
+    loadSessions(agentId: string): Promise<SessionData[]>;
+    loadMemories(agentId: string): Promise<MemoryEntry[]>;
+    commit(agentId: string, result: CurationResult, existing: MemoryEntry[]): Promise<void>;
+    search(agentId: string, query: string, topK?: number): Promise<MemoryEntry[]>;
+    /** Persist a completed session for future consolidation via `Agent.dream()`. */
+    saveSession(data: SessionData): Promise<void>;
+}

package/dist/memory/index.js

@@ -0,0 +1,8 @@
+export class WorkingMemory {
+    store = new Map();
+    set(key, value) { this.store.set(key, value); }
+    get(key, defaultValue) { return this.store.get(key) ?? defaultValue; }
+    delete(key) { this.store.delete(key); }
+    clear() { this.store.clear(); }
+    has(key) { return this.store.has(key); }
+}

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,8 @@
+import type { Message, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+export declare class AnthropicProvider implements LLMProvider {
+    private readonly apiKey;
+    private readonly model;
+    private readonly maxTokens;
+    constructor(apiKey: string, model?: string, maxTokens?: number);
+    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+}

package/dist/providers/anthropic.js

@@ -0,0 +1,89 @@
+function buildAnthropicTools(tools) {
+    return tools.map(t => ({ name: t.name, description: t.description, input_schema: JSON.parse(t.parameters) }));
+}
+export class AnthropicProvider {
+    apiKey;
+    model;
+    maxTokens;
+    constructor(apiKey, model = "claude-sonnet-4-6", maxTokens = 8096) {
+        this.apiKey = apiKey;
+        this.model = model;
+        this.maxTokens = maxTokens;
+    }
+    async *stream(messages, tools, extensions) {
+        const system = messages.filter(m => m.role === "system").map(m => m.content).join("\n\n");
+        const msgs = messages.filter(m => m.role !== "system").map(m => ({ role: m.role, content: m.content }));
+        const body = {
+            model: this.model,
+            max_tokens: this.maxTokens,
+            messages: msgs,
+            stream: true,
+            ...(system ? { system } : {}),
+            ...(tools.length ? { tools: buildAnthropicTools(tools) } : {}),
+        };
+        if (extensions?.enable_thinking) {
+            body.thinking = { type: "enabled", budget_tokens: 8000 };
+        }
+        const resp = await fetch("https://api.anthropic.com/v1/messages", {
+            method: "POST",
+            headers: {
+                "x-api-key": this.apiKey,
+                "anthropic-version": "2023-06-01",
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        if (!resp.ok)
+            throw new Error(`Anthropic ${resp.status}: ${await resp.text()}`);
+        const toolBlocks = {};
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buf += decoder.decode(value, { stream: true });
+            const lines = buf.split("\n");
+            buf = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.startsWith("data: "))
+                    continue;
+                const data = line.slice(6).trim();
+                if (data === "[DONE]")
+                    return;
+                try {
+                    const evt = JSON.parse(data);
+                    if (evt.type === "content_block_start") {
+                        const cb = evt.content_block;
+                        if (cb.type === "tool_use")
+                            toolBlocks[evt.index] = { id: cb.id, name: cb.name, argsBuf: "" };
+                    }
+                    else if (evt.type === "content_block_delta") {
+                        const d = evt.delta;
+                        const idx = evt.index;
+                        if (d.type === "text_delta")
+                            yield { type: "text_delta", delta: d.text };
+                        else if (d.type === "thinking_delta")
+                            yield { type: "thinking_delta", delta: d.thinking };
+                        else if (d.type === "input_json_delta" && toolBlocks[idx])
+                            toolBlocks[idx].argsBuf += d.partial_json;
+                    }
+                    else if (evt.type === "content_block_stop" && toolBlocks[evt.index]) {
+                        const tb = toolBlocks[evt.index];
+                        delete toolBlocks[evt.index];
+                        let args = {};
+                        try {
+                            args = JSON.parse(tb.argsBuf || "{}");
+                        }
+                        catch {
+                            args = {};
+                        }
+                        yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
+                    }
+                }
+                catch { /* skip malformed */ }
+            }
+        }
+    }
+}

package/dist/providers/openai.d.ts

@@ -0,0 +1,32 @@
+import type { Message, ToolSchema, StreamEvent, LLMProvider } from "../types.js";
+export declare class OpenAIProvider implements LLMProvider {
+    protected readonly apiKey: string;
+    protected readonly model: string;
+    protected readonly baseUrl: string;
+    constructor(apiKey: string, model?: string, baseUrl?: string);
+    protected buildTools(tools: ToolSchema[]): {
+        type: string;
+        function: {
+            name: string;
+            description: string;
+            parameters: any;
+        };
+    }[];
+    protected streamInner(messages: Message[], tools: ToolSchema[], extraBody: Record<string, unknown>, exposeReasoning?: boolean): AsyncIterable<StreamEvent>;
+    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+}
+export declare class QwenProvider extends OpenAIProvider {
+    constructor(apiKey: string, model?: string);
+    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+}
+export declare class DeepSeekProvider extends OpenAIProvider {
+    constructor(apiKey: string, model?: string);
+    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+}
+export declare class MiniMaxProvider extends OpenAIProvider {
+    constructor(apiKey: string, model?: string);
+    stream(messages: Message[], tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+}
+export declare class KimiProvider extends OpenAIProvider {
+    constructor(apiKey: string, model?: string);
+}

package/dist/providers/openai.js

@@ -0,0 +1,127 @@
+const DEEPSEEK_REASONERS = new Set(["deepseek-reasoner", "deepseek-r1"]);
+const MINIMAX_REASONERS = new Set(["MiniMax-M1", "minimax-m1"]);
+// OpenAI-compatible provider — works for OpenAI, Qwen (DashScope), DeepSeek, MiniMax, Kimi
+export class OpenAIProvider {
+    apiKey;
+    model;
+    baseUrl;
+    constructor(apiKey, model = "gpt-4o", baseUrl = "https://api.openai.com/v1") {
+        this.apiKey = apiKey;
+        this.model = model;
+        this.baseUrl = baseUrl;
+    }
+    buildTools(tools) {
+        return tools.map(t => ({ type: "function", function: { name: t.name, description: t.description, parameters: JSON.parse(t.parameters) } }));
+    }
+    async *streamInner(messages, tools, extraBody, exposeReasoning = false) {
+        const msgs = messages.map(m => ({ role: m.role, content: m.content }));
+        const body = {
+            model: this.model,
+            messages: msgs,
+            stream: true,
+            ...(tools.length ? { tools: this.buildTools(tools) } : {}),
+            ...extraBody,
+        };
+        const resp = await fetch(`${this.baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: { "Authorization": `Bearer ${this.apiKey}`, "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!resp.ok)
+            throw new Error(`OpenAI ${resp.status}: ${await resp.text()}`);
+        const toolAccum = {};
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buf += decoder.decode(value, { stream: true });
+            const lines = buf.split("\n");
+            buf = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.startsWith("data: "))
+                    continue;
+                const data = line.slice(6).trim();
+                if (data === "[DONE]")
+                    return;
+                try {
+                    const chunk = JSON.parse(data);
+                    const delta = chunk.choices?.[0]?.delta;
+                    if (!delta)
+                        continue;
+                    if (exposeReasoning && typeof delta.reasoning_content === "string" && delta.reasoning_content)
+                        yield { type: "thinking_delta", delta: delta.reasoning_content };
+                    if (typeof delta.content === "string" && delta.content)
+                        yield { type: "text_delta", delta: delta.content };
+                    for (const tc of delta.tool_calls ?? []) {
+                        const idx = tc.index;
+                        if (!toolAccum[idx])
+                            toolAccum[idx] = { id: tc.id ?? "", name: tc.function?.name ?? "", argsBuf: "" };
+                        toolAccum[idx].argsBuf += tc.function?.arguments ?? "";
+                    }
+                }
+                catch { /* skip */ }
+            }
+        }
+        for (const tb of Object.values(toolAccum)) {
+            let args = {};
+            try {
+                args = JSON.parse(tb.argsBuf || "{}");
+            }
+            catch {
+                args = {};
+            }
+            yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
+        }
+    }
+    async *stream(messages, tools, extensions) {
+        const { expose_reasoning: _, exposeReasoning: __, ...passthrough } = extensions ?? {};
+        yield* this.streamInner(messages, tools, passthrough);
+    }
+}
+export class QwenProvider extends OpenAIProvider {
+    constructor(apiKey, model = "qwen-max") {
+        super(apiKey, model, "https://dashscope.aliyuncs.com/compatible-mode/v1");
+    }
+    async *stream(messages, tools, extensions) {
+        const enableThinking = Boolean(extensions?.enableThinking);
+        const thinkingBudget = extensions?.thinkingBudget;
+        const { enableThinking: _, thinkingBudget: __, expose_reasoning: ___, exposeReasoning: ____, ...passthrough } = extensions ?? {};
+        const extra = {
+            ...passthrough,
+            ...(enableThinking ? { enable_thinking: true, ...(thinkingBudget ? { thinking_budget: thinkingBudget } : {}) } : {}),
+        };
+        yield* this.streamInner(messages, tools, extra, enableThinking);
+    }
+}
+export class DeepSeekProvider extends OpenAIProvider {
+    constructor(apiKey, model = "deepseek-chat") {
+        super(apiKey, model, "https://api.deepseek.com/v1");
+    }
+    async *stream(messages, tools, extensions) {
+        const exposeReasoning = Boolean(extensions?.exposeReasoning);
+        const isReasoner = DEEPSEEK_REASONERS.has(this.model);
+        const filteredTools = isReasoner ? [] : tools;
+        const { exposeReasoning: _, expose_reasoning: __, ...passthrough } = extensions ?? {};
+        yield* this.streamInner(messages, filteredTools, passthrough, exposeReasoning);
+    }
+}
+export class MiniMaxProvider extends OpenAIProvider {
+    constructor(apiKey, model = "MiniMax-Text-01") {
+        super(apiKey, model, "https://api.minimax.chat/v1");
+    }
+    async *stream(messages, tools, extensions) {
+        const exposeReasoning = Boolean(extensions?.exposeReasoning);
+        const isReasoner = MINIMAX_REASONERS.has(this.model);
+        const filteredTools = isReasoner ? [] : tools;
+        const { exposeReasoning: _, expose_reasoning: __, ...passthrough } = extensions ?? {};
+        yield* this.streamInner(messages, filteredTools, passthrough, exposeReasoning);
+    }
+}
+export class KimiProvider extends OpenAIProvider {
+    constructor(apiKey, model = "moonshot-v1-8k") {
+        super(apiKey, model, "https://api.moonshot.cn/v1");
+    }
+}

package/dist/safety/index.d.ts

@@ -0,0 +1,17 @@
+export declare enum PermissionMode {
+    DEFAULT = "DEFAULT",
+    PLAN = "PLAN",
+    AUTO = "AUTO"
+}
+export interface PermissionDecision {
+    allowed: boolean;
+    reason: string;
+}
+export declare class PermissionManager {
+    private mode;
+    private grants;
+    constructor(mode?: PermissionMode);
+    grant(resource: string, action: string): this;
+    revoke(resource: string, action: string): this;
+    evaluate(resource: string, action: string): PermissionDecision;
+}

package/dist/safety/index.js

@@ -0,0 +1,32 @@
+export var PermissionMode;
+(function (PermissionMode) {
+    PermissionMode["DEFAULT"] = "DEFAULT";
+    PermissionMode["PLAN"] = "PLAN";
+    PermissionMode["AUTO"] = "AUTO";
+})(PermissionMode || (PermissionMode = {}));
+export class PermissionManager {
+    mode;
+    grants = new Map();
+    constructor(mode = PermissionMode.DEFAULT) {
+        this.mode = mode;
+    }
+    grant(resource, action) {
+        if (!this.grants.has(resource))
+            this.grants.set(resource, new Set());
+        this.grants.get(resource).add(action);
+        return this;
+    }
+    revoke(resource, action) {
+        this.grants.get(resource)?.delete(action);
+        return this;
+    }
+    evaluate(resource, action) {
+        if (this.mode === PermissionMode.AUTO)
+            return { allowed: true, reason: "AUTO mode" };
+        if (this.mode === PermissionMode.PLAN)
+            return { allowed: false, reason: "PLAN mode blocks all" };
+        const actions = this.grants.get(resource);
+        const allowed = !!(actions && (actions.has(action) || actions.has("*")));
+        return { allowed, reason: allowed ? "granted" : "not granted" };
+    }
+}

package/dist/signals/index.d.ts

@@ -0,0 +1,18 @@
+export interface RuntimeSignal {
+    source: "cron" | "gateway" | "heartbeat" | "custom";
+    signalType: "event" | "job" | "alert";
+    urgency: "low" | "normal" | "high" | "critical";
+    payload: Record<string, unknown>;
+    dedupeKey?: string;
+}
+export interface SignalSource {
+    nextSignal(): Promise<RuntimeSignal | null>;
+}
+export declare class ScheduledPrompt {
+    readonly goal: string;
+    readonly runAtMs: number;
+    readonly criteria: string[];
+    readonly metadata: Record<string, unknown>;
+    constructor(goal: string, runAtMs: number, criteria?: string[], metadata?: Record<string, unknown>);
+    toSignal(): RuntimeSignal;
+}

package/dist/signals/index.js

@@ -0,0 +1,21 @@
+export class ScheduledPrompt {
+    goal;
+    runAtMs;
+    criteria;
+    metadata;
+    constructor(goal, runAtMs, criteria = [], metadata = {}) {
+        this.goal = goal;
+        this.runAtMs = runAtMs;
+        this.criteria = criteria;
+        this.metadata = metadata;
+    }
+    toSignal() {
+        return {
+            source: "cron",
+            signalType: "job",
+            urgency: "normal",
+            payload: { goal: this.goal, criteria: this.criteria, runAtMs: this.runAtMs, ...this.metadata },
+            dedupeKey: `scheduled-${this.runAtMs}`,
+        };
+    }
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,11 @@
+import type { ToolSchema, ToolResult } from "../types.js";
+export interface RegisteredTool {
+    schema: ToolSchema;
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+export declare function tool(name: string, description: string, parameters: Record<string, unknown>, fn: (args: Record<string, unknown>) => Promise<string> | string): RegisteredTool;
+export declare function executeTools(calls: {
+    id: string;
+    name: string;
+    arguments: string;
+}[], registry: Map<string, RegisteredTool>): Promise<ToolResult[]>;

package/dist/tools/index.js

@@ -0,0 +1,20 @@
+export function tool(name, description, parameters, fn) {
+    return {
+        schema: { name, description, parameters: JSON.stringify(parameters) },
+        async execute(args) { return fn(args); },
+    };
+}
+export async function executeTools(calls, registry) {
+    return Promise.all(calls.map(async (c) => {
+        const t = registry.get(c.name);
+        if (!t)
+            return { callId: c.id, output: `unknown tool: ${c.name}`, isError: true };
+        try {
+            const args = JSON.parse(c.arguments || "{}");
+            return { callId: c.id, output: await t.execute(args), isError: false };
+        }
+        catch (err) {
+            return { callId: c.id, output: String(err), isError: true };
+        }
+    }));
+}