thoughtgear 0.1.0

package/dist/classes/PromptHandler.js

@@ -0,0 +1,743 @@
+/**
+ * PromptHandler — minimal emulation of openclaw's "chain of thoughts" loop.
+ *
+ * Shape mirrors src/agents/pi-embedded-runner:
+ *   handlePrompt() persists the inbound message + a RunState, then asks the
+ *   Executor to drive the loop. Each iteration (continueRun) is stateless:
+ *   it rebuilds the prompt from ORM history, opens a model stream, executes
+ *   any tool calls, persists results, and either finishes or schedules the
+ *   next iteration. In Lambda mode the next iteration is a fresh invocation.
+ */
+import { randomUUID } from "node:crypto";
+import { GoogleGenAI } from "@google/genai";
+import OpenAI from "openai";
+/**
+ * OpenAI / Anthropic / Gemini all require tool/function names to match a
+ * narrow charset (roughly `^[A-Za-z0-9_-]+$`). Skill keys are human-friendly
+ * (may contain spaces). We translate one-way and match back by normalized key.
+ */
+function normalizeToolName(key) {
+    return key.replace(/[^A-Za-z0-9_-]+/g, "_");
+}
+export class ORM {
+    config;
+    adapter;
+    constructor(config) {
+        this.config = config;
+        this.adapter =
+            config.type === "memory"
+                ? new InMemoryOrmAdapter()
+                : config.type === "mongodb"
+                    ? new MongoOrmAdapter(config)
+                    : new SqlOrmAdapter(config);
+    }
+    saveMessage(msg) {
+        return this.adapter.saveMessage(msg);
+    }
+    getHistory(runId) {
+        return this.adapter.getHistory(runId);
+    }
+    getSessionHistory(sessionId) {
+        return this.adapter.getSessionHistory(sessionId);
+    }
+    saveRunState(state) {
+        return this.adapter.saveRunState(state);
+    }
+    getRunState(runId) {
+        return this.adapter.getRunState(runId);
+    }
+    cacheGet(key) {
+        return this.adapter.cacheGet(key);
+    }
+    cacheSet(key, value, ttl) {
+        return this.adapter.cacheSet(key, value, ttl);
+    }
+    saveMemory(scope, key, value) {
+        return this.adapter.saveMemory(scope, key, value);
+    }
+    getMemory(scope, key) {
+        return this.adapter.getMemory(scope, key);
+    }
+}
+class InMemoryOrmAdapter {
+    messages = new Map();
+    runs = new Map();
+    cache = new Map();
+    memory = new Map();
+    async saveMessage(msg) {
+        const list = this.messages.get(msg.runId) ?? [];
+        list.push(msg);
+        this.messages.set(msg.runId, list);
+    }
+    async getHistory(runId) {
+        return [...(this.messages.get(runId) ?? [])];
+    }
+    async getSessionHistory(sessionId) {
+        const out = [];
+        for (const list of this.messages.values()) {
+            for (const m of list)
+                if (m.sessionId === sessionId)
+                    out.push(m);
+        }
+        return out.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+    }
+    async saveRunState(state) {
+        this.runs.set(state.runId, { ...state });
+    }
+    async getRunState(runId) {
+        const s = this.runs.get(runId);
+        return s ? { ...s } : null;
+    }
+    async cacheGet(key) {
+        return this.cache.get(key) ?? null;
+    }
+    async cacheSet(key, value) {
+        this.cache.set(key, value);
+    }
+    async saveMemory(scope, key, value) {
+        this.memory.set(`${scope}:${key}`, value);
+    }
+    async getMemory(scope, key) {
+        return this.memory.get(`${scope}:${key}`) ?? null;
+    }
+}
+class MongoOrmAdapter {
+    cfg;
+    // Wire `mongodb` driver here. Collections: messages, run_states, cache, memory.
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    async saveMessage(_msg) {
+        /* db.collection('messages').insertOne(_msg) */
+    }
+    async getHistory(_runId) {
+        return [];
+    }
+    async getSessionHistory(_sessionId) {
+        /* db.collection('messages').find({ sessionId: _sessionId }).sort({ createdAt: 1 }) */
+        return [];
+    }
+    async saveRunState(_state) {
+        /* upsert by runId */
+    }
+    async getRunState(_runId) {
+        return null;
+    }
+    async cacheGet(_key) {
+        return null;
+    }
+    async cacheSet(_key, _value, _ttl) { }
+    async saveMemory(_scope, _key, _value) { }
+    async getMemory(_scope, _key) {
+        return null;
+    }
+}
+class SqlOrmAdapter {
+    cfg;
+    // Wire `kysely` / `pg` / `better-sqlite3`. Tables mirror Mongo collections.
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    async saveMessage(_msg) { }
+    async getHistory(_runId) {
+        return [];
+    }
+    async getSessionHistory(_sessionId) {
+        return [];
+    }
+    async saveRunState(_state) { }
+    async getRunState(_runId) {
+        return null;
+    }
+    async cacheGet(_key) {
+        return null;
+    }
+    async cacheSet(_key, _value, _ttl) { }
+    async saveMemory(_scope, _key, _value) { }
+    async getMemory(_scope, _key) {
+        return null;
+    }
+}
+export function createLLMProvider(model) {
+    switch (model.provider) {
+        case "anthropic":
+            return new AnthropicProvider(model);
+        case "openai":
+            return new OpenAIProvider(model);
+        case "google":
+            return new GoogleProvider(model);
+        case "mock":
+            return new MockProvider();
+    }
+}
+class AnthropicProvider {
+    cfg;
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    async stream(_args) {
+        // Wire @anthropic-ai/sdk messages.stream(); accumulate blocks; map
+        // content_block_delta -> onPartialReply / onReasoningStream; map
+        // tool_use blocks -> ContentBlock('tool_call'); finalize on message_stop.
+        return { blocks: [{ type: "text", text: "" }], stopReason: "end_turn" };
+    }
+}
+/**
+ * OpenAI provider — backed by the official `openai` SDK, using the
+ * Chat Completions streaming API.
+ *
+ *   - delta.content              -> ContentBlock('text')      + onPartialReply
+ *   - delta.tool_calls[].function -> ContentBlock('tool_call') (accumulated
+ *                                    across chunks; OpenAI streams arguments
+ *                                    as JSON-string deltas)
+ *   - finish_reason "stop" | "length" | "tool_calls" -> stopReason
+ */
+class OpenAIProvider {
+    cfg;
+    client;
+    constructor(cfg) {
+        this.cfg = cfg;
+        this.client = new OpenAI({ apiKey: cfg.apiKey, baseURL: cfg.baseUrl });
+    }
+    async stream(args) {
+        const messages = this.toOpenAIMessages(args.system, args.messages);
+        const tools = args.tools.length > 0
+            ? args.tools.map((t) => ({
+                type: "function",
+                function: {
+                    name: normalizeToolName(t.key),
+                    description: t.description,
+                    parameters: t.parameters ?? { type: "object", properties: {}, additionalProperties: true },
+                },
+            }))
+            : undefined;
+        const stream = await this.client.chat.completions.create({
+            model: this.cfg.name,
+            messages,
+            tools,
+            stream: true,
+        });
+        let textBuf = "";
+        let finishReason;
+        // Accumulate streamed tool calls by index.
+        const toolAcc = new Map();
+        for await (const chunk of stream) {
+            const choice = chunk.choices?.[0];
+            if (!choice)
+                continue;
+            const delta = choice.delta;
+            if (delta?.content) {
+                textBuf += delta.content;
+                args.callbacks?.onPartialReply?.(delta.content, args.runId);
+            }
+            if (delta?.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                    const idx = tc.index ?? 0;
+                    const slot = toolAcc.get(idx) ?? { argsStr: "" };
+                    if (tc.id)
+                        slot.id = tc.id;
+                    if (tc.function?.name)
+                        slot.name = tc.function.name;
+                    if (tc.function?.arguments)
+                        slot.argsStr += tc.function.arguments;
+                    toolAcc.set(idx, slot);
+                }
+            }
+            if (choice.finish_reason)
+                finishReason = choice.finish_reason;
+        }
+        const blocks = [];
+        if (textBuf) {
+            const block = { type: "text", text: textBuf };
+            blocks.push(block);
+            args.callbacks?.onBlockReply?.(block, args.runId);
+        }
+        const toolCalls = [];
+        for (const slot of toolAcc.values()) {
+            let parsed = {};
+            if (slot.argsStr) {
+                try {
+                    parsed = JSON.parse(slot.argsStr);
+                }
+                catch {
+                    parsed = { _raw: slot.argsStr };
+                }
+            }
+            const call = {
+                type: "tool_call",
+                id: slot.id ?? randomUUID(),
+                name: slot.name ?? "",
+                input: parsed,
+            };
+            toolCalls.push(call);
+            args.callbacks?.onBlockReply?.(call, args.runId);
+        }
+        blocks.push(...toolCalls);
+        let stopReason = "end_turn";
+        if (finishReason === "tool_calls" || toolCalls.length > 0)
+            stopReason = "tool_use";
+        else if (finishReason === "length")
+            stopReason = "max_tokens";
+        else if (finishReason === "content_filter")
+            stopReason = "error";
+        return { blocks, stopReason };
+    }
+    toOpenAIMessages(system, messages) {
+        const out = [
+            { role: "system", content: system },
+        ];
+        for (const msg of messages) {
+            if (msg.role === "system") {
+                const text = msg.blocks
+                    .filter((b) => b.type === "text")
+                    .map((b) => b.text)
+                    .join("\n");
+                if (text)
+                    out.push({ role: "system", content: text });
+                continue;
+            }
+            if (msg.role === "user") {
+                const parts = [];
+                for (const b of msg.blocks) {
+                    if (b.type === "text")
+                        parts.push({ type: "text", text: b.text });
+                    else if (b.type === "file" && b.file.mimeType.startsWith("image/")) {
+                        parts.push({
+                            type: "image_url",
+                            image_url: { url: `data:${b.file.mimeType};base64,${b.file.data}` },
+                        });
+                    }
+                }
+                out.push({ role: "user", content: parts.length > 0 ? parts : "" });
+                continue;
+            }
+            if (msg.role === "assistant") {
+                const text = msg.blocks
+                    .filter((b) => b.type === "text")
+                    .map((b) => b.text)
+                    .join("");
+                const toolCalls = msg.blocks
+                    .filter((b) => b.type === "tool_call")
+                    .map((b) => ({
+                    id: b.id,
+                    type: "function",
+                    function: {
+                        name: normalizeToolName(b.name),
+                        arguments: JSON.stringify(b.input ?? {}),
+                    },
+                }));
+                out.push({
+                    role: "assistant",
+                    content: text || null,
+                    ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+                });
+                continue;
+            }
+            if (msg.role === "tool") {
+                for (const b of msg.blocks) {
+                    if (b.type === "tool_result") {
+                        out.push({ role: "tool", tool_call_id: b.toolCallId, content: b.output });
+                    }
+                }
+            }
+        }
+        return out;
+    }
+}
+/**
+ * Google Gemini provider — backed by @google/genai. Streams generateContent
+ * chunks and normalizes them into ContentBlocks.
+ *
+ *   - parts[].text          -> ContentBlock('text')      + onPartialReply
+ *   - parts[].thought       -> ContentBlock('reasoning') + onReasoningStream
+ *   - parts[].functionCall  -> ContentBlock('tool_call')
+ *   - finishReason STOP|MAX_TOKENS|SAFETY|TOOL_USE -> stopReason
+ *
+ * Gemini quirks:
+ *   - System prompt goes through `systemInstruction`, not a leading message.
+ *   - Tool results return as `role: 'user'` parts of type `functionResponse`.
+ */
+class GoogleProvider {
+    cfg;
+    ai;
+    constructor(cfg) {
+        this.cfg = cfg;
+        this.ai = new GoogleGenAI({ apiKey: cfg.apiKey });
+    }
+    async stream(args) {
+        const contents = this.toGeminiContents(args.messages);
+        const config = { systemInstruction: args.system };
+        if (args.tools.length > 0) {
+            config.tools = [
+                {
+                    functionDeclarations: args.tools.map((t) => ({
+                        name: t.key,
+                        description: t.description,
+                        parameters: { type: "object", properties: {} },
+                    })),
+                },
+            ];
+        }
+        const stream = await this.ai.models.generateContentStream({
+            model: this.cfg.name,
+            contents: contents,
+            config,
+        });
+        let textBuf = "";
+        let reasoningBuf = "";
+        const toolCalls = [];
+        let finishReason;
+        for await (const chunk of stream) {
+            const parts = chunk.candidates?.[0]?.content?.parts ?? [];
+            for (const part of parts) {
+                if (typeof part.text === "string" && part.text.length > 0) {
+                    if (part.thought) {
+                        reasoningBuf += part.text;
+                        args.callbacks?.onReasoningStream?.(part.text, args.runId);
+                    }
+                    else {
+                        textBuf += part.text;
+                        args.callbacks?.onPartialReply?.(part.text, args.runId);
+                    }
+                }
+                if (part.functionCall) {
+                    const call = {
+                        type: "tool_call",
+                        id: randomUUID(),
+                        name: part.functionCall.name ?? "",
+                        input: part.functionCall.args ?? {},
+                    };
+                    toolCalls.push(call);
+                    args.callbacks?.onBlockReply?.(call, args.runId);
+                }
+            }
+            const fr = chunk.candidates?.[0]?.finishReason;
+            if (fr)
+                finishReason = fr;
+        }
+        const blocks = [];
+        if (reasoningBuf) {
+            const block = { type: "reasoning", text: reasoningBuf };
+            blocks.push(block);
+            args.callbacks?.onBlockReply?.(block, args.runId);
+        }
+        if (textBuf) {
+            const block = { type: "text", text: textBuf };
+            blocks.push(block);
+            args.callbacks?.onBlockReply?.(block, args.runId);
+        }
+        blocks.push(...toolCalls);
+        let stopReason = "end_turn";
+        if (toolCalls.length > 0)
+            stopReason = "tool_use";
+        else if (finishReason === "MAX_TOKENS")
+            stopReason = "max_tokens";
+        else if (finishReason === "SAFETY" || finishReason === "RECITATION")
+            stopReason = "error";
+        return { blocks, stopReason };
+    }
+    toGeminiContents(messages) {
+        const contents = [];
+        for (const msg of messages) {
+            if (msg.role === "system")
+                continue;
+            const role = msg.role === "assistant" ? "model" : "user";
+            const parts = [];
+            for (const block of msg.blocks) {
+                if (block.type === "text")
+                    parts.push({ text: block.text });
+                else if (block.type === "tool_call") {
+                    parts.push({ functionCall: { name: block.name, args: block.input } });
+                }
+                else if (block.type === "tool_result") {
+                    parts.push({
+                        functionResponse: {
+                            name: block.toolCallId,
+                            response: { output: block.output },
+                        },
+                    });
+                }
+                else if (block.type === "file") {
+                    parts.push({
+                        inlineData: { mimeType: block.file.mimeType, data: block.file.data },
+                    });
+                }
+            }
+            if (parts.length > 0)
+                contents.push({ role, parts });
+        }
+        return contents;
+    }
+}
+/** Deterministic fake that emits one tool call on iteration 0, text on >0. */
+class MockProvider {
+    async stream(args) {
+        const turn = args.messages.filter((m) => m.role === "assistant").length;
+        if (turn === 0 && args.tools[0]) {
+            const block = {
+                type: "tool_call",
+                id: randomUUID(),
+                name: args.tools[0].key,
+                input: { q: "demo" },
+            };
+            args.callbacks?.onBlockReply?.(block, args.runId);
+            return { blocks: [block], stopReason: "tool_use" };
+        }
+        const block = { type: "text", text: "Done." };
+        args.callbacks?.onPartialReply?.("Done.", args.runId);
+        args.callbacks?.onBlockReply?.(block, args.runId);
+        return { blocks: [block], stopReason: "end_turn" };
+    }
+}
+export class LocalExecutor {
+    handler;
+    bind(handler) {
+        this.handler = handler;
+    }
+    async scheduleNextIteration(runId) {
+        // Yield to the event loop so the current iteration's awaits unwind first.
+        await new Promise((r) => setImmediate(r));
+        await this.handler.continueRun(runId);
+    }
+}
+export class LambdaExecutor {
+    invoke;
+    constructor(invoke) {
+        this.invoke = invoke;
+    }
+    async scheduleNextIteration(runId) {
+        // Fire a fresh invocation; the entry handler routes action=continue to
+        // PromptHandler.continueRun(). The current invocation returns immediately.
+        await this.invoke({ runId, action: "continue" });
+    }
+}
+export class PromptHandler {
+    context;
+    tools;
+    model;
+    orm;
+    executor;
+    callbacks;
+    maxIterations;
+    compactionCharThreshold;
+    llm;
+    /** Session this handler is bound to. Undefined means "no session" — each
+     * prompt is an independent run with no shared history. */
+    sessionId;
+    constructor(opts) {
+        this.context = opts.context;
+        this.tools = opts.tools;
+        this.model = opts.model;
+        this.orm = opts.orm ?? new ORM(opts.db);
+        this.sessionId = opts.sessionId;
+        this.callbacks = opts.callbacks ?? {};
+        this.maxIterations = opts.maxIterations ?? 16;
+        this.compactionCharThreshold = opts.compactionCharThreshold ?? 80_000;
+        this.llm = createLLMProvider(opts.model);
+        const executor = opts.executor ?? new LocalExecutor();
+        if (executor instanceof LocalExecutor)
+            executor.bind(this);
+        this.executor = executor;
+    }
+    /**
+     * Entry point. Persists the inbound user message + initial RunState,
+     * then hands control to the Executor to drive the first iteration.
+     */
+    async handlePrompt(input) {
+        const runId = randomUUID();
+        const now = new Date();
+        const blocks = [{ type: "text", text: input.text }];
+        for (const f of input.files ?? [])
+            blocks.push({ type: "file", file: f });
+        await this.orm.saveMessage({
+            id: randomUUID(),
+            runId,
+            sessionId: this.sessionId,
+            role: "user",
+            blocks,
+            createdAt: now,
+            iteration: 0,
+        });
+        await this.orm.saveRunState({
+            runId,
+            sessionId: this.sessionId,
+            status: "pending",
+            iteration: 0,
+            createdAt: now,
+            updatedAt: now,
+        });
+        await this.executor.scheduleNextIteration(runId);
+        return { runId };
+    }
+    /**
+     * One iteration of the loop. Public so a Lambda entry-point can route
+     * { action: 'continue', runId } straight here.
+     *
+     * Phases — mirrors run/attempt.ts:
+     *   1. Load state + history.
+     *   2. Compact if oversized.
+     *   3. Build system prompt + payload.
+     *   4. Open model stream; collect blocks.
+     *   5. Persist assistant message.
+     *   6. If tool_use: execute tools, persist tool_result messages,
+     *      schedule next iteration. Else: finalize.
+     */
+    async continueRun(runId) {
+        const state = await this.orm.getRunState(runId);
+        if (!state || state.status === "done" || state.status === "failed")
+            return;
+        if (state.iteration >= this.maxIterations) {
+            await this.fail(state, `max iterations (${this.maxIterations}) exceeded`);
+            return;
+        }
+        // Session-bound handlers see every prior turn in the session; otherwise
+        // history is scoped to this single run.
+        let history = state.sessionId
+            ? await this.orm.getSessionHistory(state.sessionId)
+            : await this.orm.getHistory(runId);
+        history = await this.maybeCompact(history, state);
+        const system = this.buildSystemPrompt();
+        await this.updateState(state, { status: "streaming" });
+        let result;
+        try {
+            result = await this.llm.stream({
+                system,
+                messages: history,
+                tools: this.tools,
+                callbacks: this.callbacks,
+                runId,
+            });
+        }
+        catch (err) {
+            console.error("[PromptHandler] stream error:", err);
+            await this.fail(state, err.message);
+            return;
+        }
+        const assistantMsg = {
+            id: randomUUID(),
+            runId,
+            sessionId: state.sessionId,
+            role: "assistant",
+            blocks: result.blocks,
+            createdAt: new Date(),
+            iteration: state.iteration,
+        };
+        await this.orm.saveMessage(assistantMsg);
+        const toolCalls = result.blocks.filter((b) => b.type === "tool_call");
+        if (result.stopReason === "tool_use" && toolCalls.length > 0) {
+            await this.updateState(state, { status: "awaiting_tools" });
+            for (const call of toolCalls) {
+                this.callbacks.onToolStart?.(call, runId);
+                const resultBlock = await this.executeTool(call);
+                this.callbacks.onToolResult?.(resultBlock, runId);
+                await this.orm.saveMessage({
+                    id: randomUUID(),
+                    runId,
+                    sessionId: state.sessionId,
+                    role: "tool",
+                    blocks: [resultBlock],
+                    createdAt: new Date(),
+                    iteration: state.iteration,
+                });
+            }
+            await this.updateState(state, {
+                status: "pending",
+                iteration: state.iteration + 1,
+                lastStopReason: "tool_use",
+            });
+            await this.executor.scheduleNextIteration(runId);
+            return;
+        }
+        await this.updateState(state, { status: "done", lastStopReason: result.stopReason });
+        this.callbacks.onDone?.(runId);
+    }
+    // -------------------------------------------------------------------------
+    // Helpers
+    // -------------------------------------------------------------------------
+    buildSystemPrompt() {
+        if (this.tools.length === 0)
+            return this.context;
+        const skills = this.tools
+            .map((t) => `## ${t.key}\n${t.description}\n\n${t.content}`)
+            .join("\n\n---\n\n");
+        return `${this.context}\n\n# Available Tools / Skills\n\n${skills}`;
+    }
+    async executeTool(call) {
+        const tool = this.tools.find((t) => t.key === call.name) ??
+            this.tools.find((t) => normalizeToolName(t.key) === call.name);
+        if (!tool) {
+            return {
+                type: "tool_result",
+                toolCallId: call.id,
+                output: `Error: tool "${call.name}" not registered`,
+                isError: true,
+            };
+        }
+        // Function-style tools: run the handler and return its result.
+        if (tool.handler) {
+            try {
+                const output = await tool.handler({ params: call.input });
+                return { type: "tool_result", toolCallId: call.id, output };
+            }
+            catch (err) {
+                return {
+                    type: "tool_result",
+                    toolCallId: call.id,
+                    output: `Error executing tool "${tool.key}": ${err.message}`,
+                    isError: true,
+                };
+            }
+        }
+        // Skill-style tools: returning the skill content lets the next iteration
+        // act on its instructions.
+        return { type: "tool_result", toolCallId: call.id, output: tool.content };
+    }
+    /**
+     * Cheap stand-in for pi-embedded-runner compaction. If the transcript is
+     * over the char budget, summarize older messages into a single system note
+     * and keep the tail. Real implementation would call the model to summarize.
+     */
+    async maybeCompact(history, state) {
+        const size = history.reduce((n, m) => n + JSON.stringify(m.blocks).length, 0);
+        if (size <= this.compactionCharThreshold)
+            return history;
+        await this.updateState(state, { status: "compacting" });
+        const keep = history.slice(-4);
+        const dropped = history.slice(0, -4);
+        const summary = {
+            id: randomUUID(),
+            runId: state.runId,
+            sessionId: state.sessionId,
+            role: "system",
+            blocks: [
+                {
+                    type: "text",
+                    text: `[compacted ${dropped.length} earlier messages, ~${size} chars]`,
+                },
+            ],
+            createdAt: new Date(),
+            iteration: state.iteration,
+        };
+        await this.orm.saveMessage(summary);
+        return [summary, ...keep];
+    }
+    async updateState(state, patch) {
+        const next = { ...state, ...patch, updatedAt: new Date() };
+        Object.assign(state, next);
+        await this.orm.saveRunState(next);
+    }
+    async fail(state, error) {
+        await this.updateState(state, { status: "failed", lastError: error });
+    }
+}
+export function makeLambdaHandler(handler) {
+    return async (event) => {
+        if (event.action === "start")
+            return handler.handlePrompt({ text: event.text, files: event.files });
+        if (event.action === "continue") {
+            await handler.continueRun(event.runId);
+            return { runId: event.runId };
+        }
+    };
+}
+//# sourceMappingURL=PromptHandler.js.map