@deepstrike/sdk 0.1.12 → 0.1.14

package/dist/runtime/runner.d.ts

@@ -0,0 +1,49 @@
+import type { LLMProvider, StreamEvent, ToolSuspendEvent } from "../types.js";
+import type { DreamStore, DreamResult } from "../memory/protocols.js";
+import type { KnowledgeSource } from "../knowledge/source.js";
+import type { SignalSource } from "../signals/types.js";
+import type { SessionLog } from "./session-log.js";
+import type { ExecutionPlane } from "./execution-plane.js";
+export interface RuntimeOptions {
+    provider: LLMProvider;
+    sessionLog: SessionLog;
+    executionPlane: ExecutionPlane;
+    maxTokens: number;
+    maxTurns?: number;
+    timeoutMs?: number;
+    agentId?: string;
+    systemPrompt?: string;
+    initialMemory?: string[];
+    skillDir?: string;
+    dreamStore?: DreamStore;
+    knowledgeSource?: KnowledgeSource;
+    signalSource?: SignalSource;
+    extensions?: Record<string, unknown>;
+    governance?: {
+        setTime?(nowMs: bigint): void;
+        evaluate(name: string, argsJson: string): {
+            kind: string;
+            reason?: string;
+            retryAfterMs?: number;
+        };
+    };
+    onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
+}
+export declare class RuntimeRunner {
+    private readonly opts;
+    private interrupted;
+    constructor(opts: RuntimeOptions);
+    interrupt(): void;
+    run(req: {
+        sessionId: string;
+        goal: string;
+        criteria?: string[];
+        extensions?: Record<string, unknown>;
+    }): AsyncIterable<StreamEvent>;
+    wake(sessionId: string, extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
+    dream(agentId: string, nowMs?: number): Promise<DreamResult>;
+    private execute;
+    private appendObservations;
+}
+/** Collect all text_delta events from a run into a single string. */
+export declare function collectText(stream: AsyncIterable<StreamEvent>): Promise<string>;

package/dist/runtime/runner.js

@@ -0,0 +1,364 @@
+import { getKernel } from "../kernel.js";
+export class RuntimeRunner {
+    opts;
+    interrupted = false;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    interrupt() { this.interrupted = true; }
+    async *run(req) {
+        const prior = await this.opts.sessionLog.read(req.sessionId);
+        const midRun = isMidRun(prior);
+        if (!midRun) {
+            await this.opts.sessionLog.append(req.sessionId, {
+                kind: "run_started",
+                run_id: crypto.randomUUID(),
+                goal: req.goal,
+                criteria: req.criteria ?? [],
+                agent_id: this.opts.agentId,
+                system_prompt: this.opts.systemPrompt,
+            });
+        }
+        yield* this.execute(req.sessionId, req.goal, req.criteria ?? [], req.extensions, prior.length > 0 ? prior : undefined, midRun);
+    }
+    async *wake(sessionId, extensions) {
+        const events = await this.opts.sessionLog.read(sessionId);
+        if (events.some(e => e.event.kind === "run_terminal"))
+            return;
+        const startEntry = [...events].reverse().find(e => e.event.kind === "run_started");
+        if (!startEntry)
+            throw new Error(`No run_started event for session: ${sessionId}`);
+        const start = startEntry.event;
+        yield* this.execute(sessionId, start.goal, start.criteria, extensions, events, true);
+    }
+    async dream(agentId, nowMs = Date.now()) {
+        if (!this.opts.dreamStore)
+            throw new Error("dreamStore not configured");
+        const kernel = getKernel();
+        const sessions = await this.opts.dreamStore.loadSessions(agentId);
+        const existingMemories = await this.opts.dreamStore.loadMemories(agentId);
+        if (!sessions.length)
+            return { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 };
+        const pipeline = new kernel.IdlePipeline(agentId);
+        const action1 = pipeline.feedTrigger(sessions.map(s => ({
+            sessionId: s.sessionId, agentId: s.agentId,
+            messages: s.messages.map(m => ({
+                role: m.role, content: m.content, tokenCount: m.tokenCount,
+                toolCalls: (m.toolCalls ?? []).map(tc => ({ id: tc.id, name: tc.name, arguments: tc.arguments })),
+            })),
+            metadata: JSON.stringify(s.metadata ?? null),
+            createdAtMs: s.createdAtMs, updatedAtMs: s.updatedAtMs,
+        })), existingMemories.map(e => ({ text: e.text, score: e.score, metadata: JSON.stringify(e.metadata ?? null) })), nowMs);
+        if (action1.kind === "noop" || action1.kind === "aborted") {
+            return { sessionsProcessed: 0, insightsExtracted: 0, entriesAdded: 0, entriesRemoved: 0 };
+        }
+        if (action1.kind !== "synthesize_insights")
+            throw new Error(`unexpected: ${action1.kind}`);
+        let synthesisText = "";
+        const providerState = this.opts.provider.createRunState?.();
+        const synthMsgs = (action1.messages ?? []);
+        const synthContext = {
+            systemText: synthMsgs.filter(m => m.role === "system").map(m => m.content).join("\n\n"),
+            turns: synthMsgs.filter(m => m.role !== "system"),
+        };
+        for await (const evt of this.opts.provider.stream(synthContext, [], undefined, providerState)) {
+            if (evt.type === "text_delta")
+                synthesisText += evt.delta;
+        }
+        const action2 = pipeline.feedSynthesisResult(synthesisText);
+        if (action2.kind !== "commit_memories")
+            throw new Error(`unexpected: ${action2.kind}`);
+        const cr = action2.curationResult;
+        const rr = action2.runResult;
+        const dsResult = {
+            toAdd: (cr.toAdd ?? []).map((e) => ({
+                text: e.text, score: e.score, metadata: tryParseJson(e.metadata),
+            })),
+            toRemoveIndices: (cr.toRemoveIndices ?? []).map(Number),
+            stats: {
+                insightsProcessed: cr.stats?.insightsProcessed ?? 0,
+                duplicatesRemoved: cr.stats?.duplicatesRemoved ?? 0,
+                conflictsResolved: cr.stats?.conflictsResolved ?? 0,
+                entriesAdded: cr.stats?.entriesAdded ?? 0,
+            },
+        };
+        await this.opts.dreamStore.commit(agentId, dsResult, existingMemories);
+        return {
+            sessionsProcessed: rr.sessionsProcessed,
+            insightsExtracted: rr.insightsExtracted,
+            entriesAdded: cr.stats?.entriesAdded ?? 0,
+            entriesRemoved: (cr.toRemoveIndices ?? []).length,
+        };
+    }
+    async *execute(sessionId, goal, criteria, extensions, priorEvents, resumeMidRun = false) {
+        this.interrupted = false;
+        const kernel = getKernel();
+        const ext = { ...this.opts.extensions, ...(extensions ?? {}) };
+        const providerState = this.opts.provider.createRunState?.();
+        let nextCompressedArchiveStart = nextArchivedSeqStart(priorEvents);
+        // Three-layer policy merge: explicit RuntimeOptions > provider.runtimePolicy() > defaults
+        const providerPolicy = this.opts.provider.runtimePolicy?.() ?? {};
+        const effectiveMaxTurns = this.opts.maxTurns ?? providerPolicy.maxTurns ?? 25;
+        const effectiveTimeoutMs = this.opts.timeoutMs ?? providerPolicy.timeoutMs;
+        const sm = new kernel.LoopStateMachine({
+            maxTokens: this.opts.maxTokens,
+            maxTurns: effectiveMaxTurns,
+            timeoutMs: effectiveTimeoutMs !== undefined ? BigInt(effectiveTimeoutMs) : undefined,
+        });
+        const router = new kernel.SignalRouter(256);
+        sm.setTools(this.opts.executionPlane.schemas());
+        if (this.opts.systemPrompt) {
+            sm.addSystemMessage(this.opts.systemPrompt, Math.max(1, Math.ceil(this.opts.systemPrompt.length / 4)));
+        }
+        if (this.opts.initialMemory) {
+            for (const mem of this.opts.initialMemory) {
+                sm.addMemoryMessage(mem, Math.max(1, Math.ceil(mem.length / 4)));
+            }
+        }
+        if (this.opts.skillDir) {
+            const { scanSkillDir } = await import("../skills/loader.js");
+            const metas = await scanSkillDir(this.opts.skillDir);
+            sm.setAvailableSkills(metas.map((m) => ({
+                name: m.name, description: m.description, whenToUse: m.whenToUse,
+                effort: m.effort, estimatedTokens: m.estimatedTokens ?? 0,
+            })));
+        }
+        if (this.opts.dreamStore && this.opts.agentId)
+            sm.setMemoryEnabled(true);
+        if (this.opts.knowledgeSource)
+            sm.setKnowledgeEnabled(true);
+        if (priorEvents && priorEvents.length > 0) {
+            sm.preloadHistory(replayMessages(priorEvents));
+        }
+        const sessionStart = Date.now();
+        let action = resumeMidRun
+            ? sm.resumeAfterPreload()
+            : sm.start({ goal, criteria });
+        while (!sm.isTerminal()) {
+            nextCompressedArchiveStart = await this.appendObservations(sessionId, sm, nextCompressedArchiveStart);
+            if (this.interrupted) {
+                action = sm.feedTimeout();
+                break;
+            }
+            if (this.opts.signalSource) {
+                const sig = await this.opts.signalSource.nextSignal();
+                if (sig) {
+                    const kernelSig = {
+                        id: crypto.randomUUID(),
+                        source: sig.source ?? "custom",
+                        signalType: sig.signalType ?? "event",
+                        urgency: sig.urgency ?? "normal",
+                        summary: String(sig.payload?.goal ?? sig.kind ?? "signal"),
+                        payload: JSON.stringify(sig.payload ?? {}),
+                        dedupeKey: sig.dedupeKey,
+                        timestampMs: Date.now(),
+                    };
+                    const disposition = router.ingest(kernelSig, action.kind === "execute_tools");
+                    if (disposition === "interrupt_now") {
+                        action = sm.feedTimeout();
+                        break;
+                    }
+                }
+            }
+            let queued = router.next();
+            while (queued) {
+                if (queued.urgency === "critical") {
+                    action = sm.feedTimeout();
+                    break;
+                }
+                queued = router.next();
+            }
+            if (sm.isTerminal())
+                break;
+            if (action.kind === "call_llm") {
+                const finalToolCalls = [];
+                let finalText = "";
+                const context = action.context;
+                const tools = (action.tools ?? []);
+                let turnTokens = 0;
+                try {
+                    for await (const evt of this.opts.provider.stream(context, tools, Object.keys(ext).length ? ext : undefined, providerState)) {
+                        if (evt.type === "usage") {
+                            turnTokens = evt.totalTokens;
+                            continue;
+                        }
+                        yield evt;
+                        if (evt.type === "text_delta")
+                            finalText += evt.delta;
+                        else if (evt.type === "tool_call") {
+                            const tc = evt;
+                            finalToolCalls.push({ id: tc.id, name: tc.name, arguments: JSON.stringify(tc.arguments) });
+                        }
+                    }
+                }
+                catch (err) {
+                    yield { type: "error", message: String(err) };
+                    action = sm.feedTimeout();
+                    break;
+                }
+                action = sm.feedLlmResponse({
+                    role: "assistant",
+                    content: finalText,
+                    toolCalls: finalToolCalls,
+                    tokenCount: turnTokens || undefined,
+                });
+                await this.opts.sessionLog.append(sessionId, {
+                    kind: "llm_completed",
+                    turn: sm.turn,
+                    content: finalText,
+                    token_count: turnTokens || undefined,
+                    tool_calls: finalToolCalls,
+                });
+            }
+            else if (action.kind === "execute_tools") {
+                const allCalls = action.calls ?? [];
+                await this.opts.sessionLog.append(sessionId, { kind: "tool_requested", turn: sm.turn, calls: allCalls });
+                const runCtx = {
+                    agentId: this.opts.agentId,
+                    skillDir: this.opts.skillDir,
+                    dreamStore: this.opts.dreamStore,
+                    knowledgeSource: this.opts.knowledgeSource,
+                    governance: this.opts.governance,
+                    onToolSuspend: this.opts.onToolSuspend,
+                };
+                const toolResults = [];
+                for await (const evt of this.opts.executionPlane.executeAll(allCalls, runCtx)) {
+                    yield evt;
+                    if (evt.type === "tool_result") {
+                        const tre = evt;
+                        toolResults.push({ callId: tre.callId, output: tre.content, isError: tre.isError });
+                    }
+                }
+                await this.opts.sessionLog.append(sessionId, {
+                    kind: "tool_completed",
+                    turn: sm.turn,
+                    results: toolResults.map(r => ({
+                        call_id: r.callId,
+                        output: r.output,
+                        is_error: r.isError,
+                        token_count: r.tokenCount,
+                    })),
+                });
+                action = sm.feedToolResults(toolResults);
+            }
+            else if (action.kind === "done") {
+                break;
+            }
+        }
+        const result = action.result;
+        const status = result?.termination ?? "error";
+        const turnsUsed = result ? Math.max(1, result.turnsUsed) : 0;
+        const totalTokens = result?.totalTokensUsed ? Number(result.totalTokensUsed) : 0;
+        nextCompressedArchiveStart = await this.appendObservations(sessionId, sm, nextCompressedArchiveStart);
+        await this.opts.sessionLog.append(sessionId, { kind: "run_terminal", reason: status, turns_used: turnsUsed, total_tokens: totalTokens });
+        if (this.opts.dreamStore && this.opts.agentId) {
+            const newMsgs = sm.drainNewMessages().map(m => ({
+                role: m.role,
+                content: m.content,
+                contentParts: m.contentParts,
+                tokenCount: m.tokenCount,
+                toolCalls: m.toolCalls?.length ? m.toolCalls : undefined,
+            }));
+            if (newMsgs.length > 0) {
+                try {
+                    await this.opts.dreamStore.saveSession({
+                        sessionId: crypto.randomUUID(),
+                        agentId: this.opts.agentId,
+                        messages: newMsgs,
+                        metadata: null,
+                        createdAtMs: sessionStart,
+                        updatedAtMs: Date.now(),
+                    });
+                }
+                catch { /* non-fatal */ }
+            }
+        }
+        yield { type: "done", iterations: turnsUsed, totalTokens, status };
+    }
+    async appendObservations(sessionId, sm, nextArchiveStart) {
+        const observations = sm.takeObservations();
+        for (const obs of observations) {
+            if (obs.kind !== "compressed")
+                continue;
+            const latest = await this.opts.sessionLog.latestSeq(sessionId);
+            if (latest < nextArchiveStart)
+                continue;
+            const end = latest;
+            const compressedSeq = await this.opts.sessionLog.append(sessionId, {
+                kind: "compressed",
+                turn: sm.turn,
+                archived_seq_range: [nextArchiveStart, end],
+            });
+            nextArchiveStart = compressedSeq + 1;
+        }
+        return nextArchiveStart;
+    }
+}
+function isMidRun(events) {
+    return events.length > 0 && !events.some(e => e.event.kind === "run_terminal");
+}
+/**
+ * Replay session events into Message[] for preloadHistory.
+ * run_started → user turn; llm_completed → assistant; tool_completed → tool messages.
+ */
+function replayMessages(events) {
+    const messages = [];
+    for (const { event: e } of events) {
+        if (e.kind === "run_started") {
+            const userText = e.criteria.length
+                ? `${e.goal}\n\nCriteria:\n${e.criteria.map((c, i) => `${i + 1}. ${c}`).join("\n")}`
+                : e.goal;
+            messages.push({
+                role: "user",
+                content: userText,
+                toolCalls: [],
+                tokenCount: Math.max(1, Math.ceil(userText.length / 4)),
+            });
+        }
+        else if (e.kind === "llm_completed") {
+            messages.push({
+                role: "assistant",
+                content: e.content,
+                toolCalls: e.tool_calls ?? [],
+                tokenCount: e.token_count,
+            });
+        }
+        else if (e.kind === "tool_completed") {
+            for (const r of e.results) {
+                messages.push({
+                    role: "tool",
+                    content: "",
+                    toolCalls: [],
+                    contentParts: [{ type: "tool_result", callId: r.call_id, output: r.output, isError: r.is_error ?? false }],
+                    tokenCount: r.token_count,
+                });
+            }
+        }
+    }
+    return messages;
+}
+function nextArchivedSeqStart(events) {
+    let next = 0;
+    for (const { event } of events ?? []) {
+        if (event.kind === "compressed")
+            next = Math.max(next, event.archived_seq_range[1] + 1);
+    }
+    return next;
+}
+function tryParseJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return null;
+    }
+}
+/** Collect all text_delta events from a run into a single string. */
+export async function collectText(stream) {
+    let text = "";
+    for await (const evt of stream) {
+        if (evt.type === "text_delta")
+            text += evt.delta;
+    }
+    return text;
+}

package/dist/runtime/session-log.d.ts

@@ -0,0 +1,67 @@
+import type { ToolCall } from "../types.js";
+export type SessionEvent = {
+    kind: "run_started";
+    run_id: string;
+    goal: string;
+    criteria: string[];
+    agent_id?: string;
+    system_prompt?: string;
+} | {
+    kind: "llm_completed";
+    turn: number;
+    content: string;
+    token_count?: number;
+    tool_calls: ToolCall[];
+} | {
+    kind: "tool_requested";
+    turn: number;
+    calls: ToolCall[];
+} | {
+    kind: "tool_completed";
+    turn: number;
+    results: Array<{
+        call_id: string;
+        output: string;
+        is_error?: boolean;
+        token_count?: number;
+    }>;
+} | {
+    kind: "compressed";
+    turn: number;
+    archived_seq_range: [number, number];
+} | {
+    kind: "run_terminal";
+    reason: string;
+    turns_used: number;
+    total_tokens: number;
+};
+export interface SessionLog {
+    append(sessionId: string, event: SessionEvent): Promise<number>;
+    read(sessionId: string, fromSeq?: number): Promise<Array<{
+        seq: number;
+        event: SessionEvent;
+    }>>;
+    latestSeq(sessionId: string): Promise<number>;
+}
+export declare class InMemorySessionLog implements SessionLog {
+    private store;
+    append(sessionId: string, event: SessionEvent): Promise<number>;
+    read(sessionId: string, fromSeq?: number): Promise<Array<{
+        seq: number;
+        event: SessionEvent;
+    }>>;
+    latestSeq(sessionId: string): Promise<number>;
+}
+export declare class FileSessionLog implements SessionLog {
+    private dir;
+    private seqCounters;
+    constructor(dir: string);
+    private path;
+    private nextSeq;
+    append(sessionId: string, event: SessionEvent): Promise<number>;
+    read(sessionId: string, fromSeq?: number): Promise<Array<{
+        seq: number;
+        event: SessionEvent;
+    }>>;
+    latestSeq(sessionId: string): Promise<number>;
+}

package/dist/runtime/session-log.js

@@ -0,0 +1,84 @@
+import { createWriteStream, createReadStream } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+export class InMemorySessionLog {
+    store = new Map();
+    async append(sessionId, event) {
+        if (!this.store.has(sessionId))
+            this.store.set(sessionId, []);
+        const entries = this.store.get(sessionId);
+        const seq = entries.length;
+        entries.push({ seq, event });
+        return seq;
+    }
+    async read(sessionId, fromSeq = 0) {
+        return (this.store.get(sessionId) ?? []).filter(e => e.seq >= fromSeq);
+    }
+    async latestSeq(sessionId) {
+        const entries = this.store.get(sessionId);
+        return entries ? entries.length - 1 : -1;
+    }
+}
+// Single-writer per session. Safe for concurrent appends within one instance.
+// Cross-instance (multi-process) safety requires an external lock.
+export class FileSessionLog {
+    dir;
+    // Lazy-initialized per-session counter. Avoids re-reading the file on every append.
+    seqCounters = new Map();
+    constructor(dir) {
+        this.dir = dir;
+    }
+    path(sessionId) {
+        return join(this.dir, `${sessionId}.jsonl`);
+    }
+    async nextSeq(sessionId) {
+        if (!this.seqCounters.has(sessionId)) {
+            const existing = await this.read(sessionId);
+            this.seqCounters.set(sessionId, existing.length);
+        }
+        const seq = this.seqCounters.get(sessionId);
+        this.seqCounters.set(sessionId, seq + 1);
+        return seq;
+    }
+    async append(sessionId, event) {
+        await mkdir(this.dir, { recursive: true });
+        const seq = await this.nextSeq(sessionId);
+        await new Promise((resolve, reject) => {
+            const ws = createWriteStream(this.path(sessionId), { flags: "a" });
+            ws.write(JSON.stringify({ seq, event }) + "\n", err => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+            ws.end();
+        });
+        return seq;
+    }
+    async read(sessionId, fromSeq = 0) {
+        const results = [];
+        try {
+            const rl = createInterface({
+                input: createReadStream(this.path(sessionId)),
+                crlfDelay: Infinity,
+            });
+            for await (const line of rl) {
+                if (!line.trim())
+                    continue;
+                const entry = JSON.parse(line);
+                if (entry.seq >= fromSeq)
+                    results.push(entry);
+            }
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+        return results;
+    }
+    async latestSeq(sessionId) {
+        const entries = await this.read(sessionId);
+        return entries.length - 1;
+    }
+}

package/dist/tools/index.d.ts

@@ -1,9 +1,14 @@
-import type { ToolSchema, ToolResult } from "../types.js";
+import type { ToolChunk, ToolSchema, ToolResult } from "../types.js";
 export interface RegisteredTool {
     schema: ToolSchema;
-    execute(args: Record<string, unknown>): Promise<string>;
+    execute(args: Record<string, unknown>): Promise<string> | AsyncIterable<ToolChunk>;
 }
 export declare function tool(name: string, description: string, parameters: Record<string, unknown>, fn: (args: Record<string, unknown>) => Promise<string> | string): RegisteredTool;
+export declare function streamingTool(name: string, description: string, parameters: Record<string, unknown>, fn: (args: Record<string, unknown>) => AsyncIterable<ToolChunk>): RegisteredTool;
+export declare function isAsyncIterable<T>(value: unknown): value is AsyncIterable<T>;
+export declare function normalizeToolChunk(chunk: ToolChunk): Exclude<ToolChunk, string>;
+export declare function toolChunkText(chunk: ToolChunk): string;
+export declare function validateToolArguments(schemaJson: string, args: Record<string, unknown>): string | undefined;
 export declare function executeTools(calls: {
     id: string;
     name: string;

package/dist/tools/index.js

@@ -4,6 +4,80 @@ export function tool(name, description, parameters, fn) {
         async execute(args) { return fn(args); },
     };
 }
+export function streamingTool(name, description, parameters, fn) {
+    return {
+        schema: { name, description, parameters: JSON.stringify(parameters) },
+        execute(args) { return fn(args); },
+    };
+}
+export function isAsyncIterable(value) {
+    return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+export function normalizeToolChunk(chunk) {
+    return typeof chunk === "string" ? { type: "text", text: chunk } : chunk;
+}
+export function toolChunkText(chunk) {
+    const normalized = normalizeToolChunk(chunk);
+    return normalized.type === "text" ? normalized.text : "";
+}
+export function validateToolArguments(schemaJson, args) {
+    let schema;
+    try {
+        schema = JSON.parse(schemaJson);
+    }
+    catch {
+        return "invalid tool schema";
+    }
+    return validateValue(schema, args, "$", true);
+}
+function validateValue(schema, value, path, isRoot = false) {
+    const expectedType = schema.type;
+    if (typeof expectedType === "string") {
+        if (expectedType === "object") {
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                return `${path} must be object`;
+            const obj = value;
+            for (const required of schema.required ?? []) {
+                if (!(required in obj))
+                    return `${path}.${required} is required`;
+            }
+            const properties = schema.properties ?? {};
+            for (const [key, child] of Object.entries(properties)) {
+                if (key in obj) {
+                    const err = validateValue(child, obj[key], `${path}.${key}`);
+                    if (err)
+                        return err;
+                }
+            }
+        }
+        else if (expectedType === "array") {
+            if (!Array.isArray(value))
+                return `${path} must be array`;
+        }
+        else if (expectedType === "string") {
+            if (typeof value !== "string")
+                return `${path} must be string`;
+        }
+        else if (expectedType === "number") {
+            if (typeof value !== "number" || Number.isNaN(value))
+                return `${path} must be number`;
+        }
+        else if (expectedType === "integer") {
+            if (!Number.isInteger(value))
+                return `${path} must be integer`;
+        }
+        else if (expectedType === "boolean") {
+            if (typeof value !== "boolean")
+                return `${path} must be boolean`;
+        }
+    }
+    else if (isRoot && (!value || typeof value !== "object" || Array.isArray(value))) {
+        return `${path} must be object`;
+    }
+    if (Array.isArray(schema.enum) && !schema.enum.includes(value))
+        return `${path} must be one of enum values`;
+    return undefined;
+}
 export async function executeTools(calls, registry) {
     return Promise.all(calls.map(async (c) => {
         const t = registry.get(c.name);
@@ -11,7 +85,16 @@ export async function executeTools(calls, registry) {
             return { callId: c.id, output: `unknown tool: ${c.name}`, isError: true };
         try {
             const args = JSON.parse(c.arguments || "{}");
+            const validationError = validateToolArguments(t.schema.parameters, args);
+            if (validationError)
+                return { callId: c.id, output: `invalid arguments: ${validationError}`, isError: true };
             const output = await t.execute(args);
+            if (isAsyncIterable(output)) {
+                let combined = "";
+                for await (const chunk of output)
+                    combined += toolChunkText(chunk);
+                return { callId: c.id, output: combined, isError: false };
+            }
             return { callId: c.id, output, isError: false };
         }
         catch (err) {