@best-agent/cli 0.0.2-beta.8 → 0.0.2-beta.9

package/dist/goatchain-adapter.d.ts

@@ -1,41 +0,0 @@
-import type { AgentRuntime } from "@best-agent/engine";
-import { type ThreadDetail, type ThreadId, type ThreadMode } from "@best-agent/protocol";
-import { type BridgeMessage, createBestAgentNativeBridge, type BestAgentSessionsApi } from "./best-agent-native-bridge.js";
-type ACPMessage = Readonly<{
-    content?: unknown;
-    metadata?: Record<string, unknown>;
-    reasoning_content?: string;
-    role: "assistant" | "tool" | "user";
-    tool_call_id?: string;
-    tool_calls?: ReadonlyArray<{
-        function: {
-            arguments: string;
-            name: string;
-        };
-        id: string;
-        type: "function";
-    }>;
-}>;
-type NativeBridge = ReturnType<typeof createBestAgentNativeBridge>;
-type NativeAgent = NativeBridge["agent"];
-type GoatChainBridgeAgent = NativeAgent & Readonly<{
-    receiveMessage: (messages: readonly unknown[], metadata?: Record<string, unknown>) => AsyncIterable<ACPMessage>;
-}>;
-export type GoatChainSessionsApi = BestAgentSessionsApi;
-export declare function resolveInitialGoatChainThread(runtime: AgentRuntime, options: Readonly<{
-    latest?: boolean;
-    resumeThreadId?: string;
-    threadMode?: ThreadMode;
-}>): Promise<ThreadDetail>;
-export declare function createGoatChainBridge(options: Readonly<{
-    agentProfile?: string;
-    runtime: AgentRuntime;
-    threadMode?: ThreadMode;
-}>): Readonly<{
-    agent: GoatChainBridgeAgent;
-    attachStore: (store: unknown) => void;
-    hydrateThread: (threadId: ThreadId) => Promise<BridgeMessage[]>;
-    sessions: GoatChainSessionsApi;
-}>;
-export {};
-//# sourceMappingURL=goatchain-adapter.d.ts.map

package/dist/goatchain-adapter.js

@@ -1,499 +0,0 @@
-import { extractPromptText, normalizePromptContentParts, } from "@best-agent/protocol";
-import { createBestAgentNativeBridge, resolveInitialBestAgentThread, } from "./best-agent-native-bridge.js";
-const DEFAULT_ASSISTANT_TEXT_STREAM_ID = "__default_assistant_text__";
-function createAsyncQueue(opts) {
-    const state = {
-        closed: false,
-        pending: [],
-        waiters: [],
-    };
-    let closedNotified = false;
-    const notifyClosed = () => {
-        if (closedNotified)
-            return;
-        closedNotified = true;
-        opts?.onClose?.();
-    };
-    return {
-        close() {
-            if (state.closed)
-                return;
-            state.closed = true;
-            while (state.waiters.length > 0)
-                state.waiters.shift()?.({ done: true, value: undefined });
-            notifyClosed();
-        },
-        push(value) {
-            if (state.closed)
-                return;
-            const waiter = state.waiters.shift();
-            if (waiter) {
-                waiter({ done: false, value });
-                return;
-            }
-            state.pending.push(value);
-        },
-        [Symbol.asyncIterator]() {
-            return {
-                next() {
-                    if (state.pending.length > 0) {
-                        return Promise.resolve({
-                            done: false,
-                            value: state.pending.shift(),
-                        });
-                    }
-                    if (state.closed)
-                        return Promise.resolve({ done: true, value: undefined });
-                    return new Promise((resolve) => {
-                        state.waiters.push(resolve);
-                    });
-                },
-                return() {
-                    if (!state.closed) {
-                        state.closed = true;
-                        while (state.waiters.length > 0)
-                            state.waiters.shift()?.({ done: true, value: undefined });
-                    }
-                    notifyClosed();
-                    return Promise.resolve({ done: true, value: undefined });
-                },
-            };
-        },
-    };
-}
-function normalizeText(value) {
-    return String(value ?? "").trim();
-}
-function asRecord(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return {};
-    return value;
-}
-function serializeUnknown(value) {
-    if (typeof value === "string")
-        return value;
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return String(value);
-    }
-}
-function makeDoneMessage(input) {
-    return {
-        content: "",
-        metadata: {
-            done: true,
-            ...(input.error ? { error: input.error } : {}),
-            stopReason: input.stopReason,
-        },
-        role: "assistant",
-    };
-}
-function makeAssistantStreamMessage(content, originalEventType, metadata = {}) {
-    return {
-        content,
-        metadata: {
-            ...metadata,
-            originalEventType,
-        },
-        role: "assistant",
-    };
-}
-function extractLatestUserPrompt(messages) {
-    for (let index = messages.length - 1; index >= 0; index -= 1) {
-        const message = asRecord(messages[index]);
-        if (normalizeText(message.role) !== "user")
-            continue;
-        const prompt = extractPromptText(message.content);
-        if (prompt)
-            return prompt;
-    }
-    return "";
-}
-function extractLatestUserPromptContent(messages) {
-    for (let index = messages.length - 1; index >= 0; index -= 1) {
-        const message = asRecord(messages[index]);
-        if (normalizeText(message.role) !== "user")
-            continue;
-        const content = normalizePromptContentParts(message.content);
-        if (content?.length)
-            return content;
-    }
-    return undefined;
-}
-function readAbortSignal(metadata) {
-    const signal = metadata.signal ?? metadata.abortSignal;
-    return signal instanceof AbortSignal ? signal : undefined;
-}
-function serializeToolArguments(input) {
-    if (Object.keys(input).length === 1 && typeof input._raw === "string") {
-        return input._raw;
-    }
-    try {
-        return JSON.stringify(input);
-    }
-    catch {
-        return "";
-    }
-}
-function toolOutputFromEvent(output) {
-    const record = asRecord(output);
-    const structuredContent = asRecord(record.structuredContent);
-    const value = "output" in record ? record.output : output;
-    return {
-        content: serializeUnknown(value),
-        ...(Object.keys(structuredContent).length > 0 ? { structuredContent } : {}),
-    };
-}
-function errorMessage(error) {
-    if (error instanceof Error)
-        return error.message;
-    return normalizeText(error) || "Unknown error";
-}
-async function openOrEnsureSession(agent, sessionId) {
-    const openSession = agent.openSession;
-    if (typeof openSession === "function") {
-        const existing = await openSession(sessionId);
-        if (existing)
-            return existing;
-    }
-    const ensureSession = agent.ensureSession;
-    if (typeof ensureSession === "function")
-        return await ensureSession({ sessionId });
-    return null;
-}
-export async function resolveInitialGoatChainThread(runtime, options) {
-    return await resolveInitialBestAgentThread(runtime, options);
-}
-export function createGoatChainBridge(options) {
-    const bridge = createBestAgentNativeBridge(options);
-    const pendingActions = new Map();
-    const receiveMessageStream = async function* (messages, rawMetadata = {}) {
-        const metadata = rawMetadata;
-        const sessionId = normalizeText(metadata.session_id);
-        if (!sessionId) {
-            yield makeDoneMessage({
-                error: "Missing session_id for GoatChain chat.",
-                stopReason: "failed",
-            });
-            return;
-        }
-        const session = await openOrEnsureSession(bridge.agent, sessionId);
-        if (!session) {
-            yield makeDoneMessage({
-                error: "Session bridge is unavailable.",
-                stopReason: "failed",
-            });
-            return;
-        }
-        const pending = pendingActions.get(sessionId);
-        const signal = readAbortSignal(metadata);
-        let stream;
-        if (pending) {
-            if (pending.kind === "tool_approval") {
-                const decision = pending.toolCallId
-                    ? metadata.toolContext?.approval?.decisions?.[pending.toolCallId]
-                    : undefined;
-                if (!decision) {
-                    yield makeDoneMessage({
-                        error: `Missing approval decision for ${pending.toolCallId ?? pending.actionId}.`,
-                        stopReason: "failed",
-                    });
-                    return;
-                }
-                stream = session.resume({
-                    actionId: pending.actionId,
-                    alwaysAllowForConversation: metadata.toolContext?.approval?.alwaysAllowForConversation,
-                    approved: decision.approved,
-                    kind: "tool_approval",
-                    ...(decision.reason ? { reason: decision.reason } : {}),
-                    ...(pending.toolCallId ? { toolCallId: pending.toolCallId } : {}),
-                }, { signal });
-            }
-            else {
-                const answers = pending.toolCallId
-                    ? metadata.toolContext?.askUser?.answers?.[pending.toolCallId]
-                    : undefined;
-                const rejectedReason = pending.toolCallId
-                    ? metadata.toolContext?.askUser?.rejected?.[pending.toolCallId]
-                    : undefined;
-                if (!answers && !rejectedReason) {
-                    yield makeDoneMessage({
-                        error: `Missing ask-user answers for ${pending.toolCallId ?? pending.actionId}.`,
-                        stopReason: "failed",
-                    });
-                    return;
-                }
-                stream = session.resume({
-                    actionId: pending.actionId,
-                    answers: { ...answers },
-                    kind: "ask_user",
-                    ...(pending.toolCallId ? { toolCallId: pending.toolCallId } : {}),
-                    ...(rejectedReason ? { reason: rejectedReason, rejected: true } : {}),
-                }, { signal });
-            }
-        }
-        else {
-            const prompt = extractLatestUserPrompt(messages);
-            const promptContent = extractLatestUserPromptContent(messages);
-            const attach = metadata.resume === true;
-            if (!prompt && !promptContent?.length && !attach) {
-                yield makeDoneMessage({
-                    error: "Missing user prompt.",
-                    stopReason: "failed",
-                });
-                return;
-            }
-            stream = session.run({
-                content: promptContent?.length ? promptContent : prompt,
-                ...(attach ? { metadata: { resume: true } } : {}),
-            }, { signal });
-        }
-        const streamedAssistantTextByStreamId = new Map();
-        const readStreamedAssistantText = () => [...streamedAssistantTextByStreamId.values()].join("");
-        const setAssistantStreamText = (streamId, content) => {
-            streamedAssistantTextByStreamId.set(streamId || DEFAULT_ASSISTANT_TEXT_STREAM_ID, content);
-        };
-        try {
-            for await (const event of stream) {
-                const record = asRecord(event);
-                const eventType = normalizeText(record.type);
-                if (eventType === "assistant.message") {
-                    const message = asRecord(record.message);
-                    const content = normalizeText(message.content);
-                    const thinking = normalizeText(message.thinking);
-                    if (thinking) {
-                        yield {
-                            ...(content ? { content } : {}),
-                            reasoning_content: thinking,
-                            role: "assistant",
-                        };
-                        if (!content)
-                            continue;
-                    }
-                    if (content) {
-                        if (readStreamedAssistantText() && content === readStreamedAssistantText()) {
-                            continue;
-                        }
-                        streamedAssistantTextByStreamId.clear();
-                        setAssistantStreamText(undefined, content);
-                        yield makeAssistantStreamMessage(content, "text_end", {
-                            settled: true,
-                        });
-                    }
-                    continue;
-                }
-                if (eventType === "assistant.delta") {
-                    const delta = String(record.delta ?? "");
-                    if (delta) {
-                        const streamId = normalizeText(record.streamId);
-                        const resolvedStreamId = streamId || DEFAULT_ASSISTANT_TEXT_STREAM_ID;
-                        streamedAssistantTextByStreamId.set(resolvedStreamId, `${streamedAssistantTextByStreamId.get(resolvedStreamId) ?? ""}${delta}`);
-                        yield makeAssistantStreamMessage(delta, "text_delta", streamId ? { streamId } : {});
-                    }
-                    continue;
-                }
-                if (eventType === "assistant.reset") {
-                    const streamId = normalizeText(record.streamId);
-                    if (streamId) {
-                        if (streamedAssistantTextByStreamId.has(streamId)) {
-                            streamedAssistantTextByStreamId.set(streamId, "");
-                        }
-                    }
-                    else {
-                        streamedAssistantTextByStreamId.clear();
-                    }
-                    yield {
-                        metadata: {
-                            originalEventType: "text_reset",
-                            ...(streamId ? { streamId } : {}),
-                        },
-                        role: "assistant",
-                    };
-                    continue;
-                }
-                if (eventType === "thinking.started") {
-                    yield {
-                        metadata: { originalEventType: "thinking_start" },
-                        role: "assistant",
-                    };
-                    continue;
-                }
-                if (eventType === "thinking.delta") {
-                    const delta = String(record.delta ?? "");
-                    yield {
-                        metadata: { originalEventType: "thinking_delta" },
-                        reasoning_content: delta,
-                        role: "assistant",
-                    };
-                    continue;
-                }
-                if (eventType === "thinking.finished") {
-                    yield {
-                        metadata: { originalEventType: "thinking_end" },
-                        reasoning_content: normalizeText(record.content),
-                        role: "assistant",
-                    };
-                    continue;
-                }
-                if (eventType === "tool.started") {
-                    if (normalizeText(record.subagentId)) {
-                        continue;
-                    }
-                    const toolName = normalizeText(record.toolName) || "tool";
-                    const toolCallId = normalizeText(record.toolCallId) || "tool";
-                    const toolInput = asRecord(record.input);
-                    yield {
-                        metadata: record.originalEventType
-                            ? { originalEventType: record.originalEventType }
-                            : undefined,
-                        role: "assistant",
-                        tool_calls: [
-                            {
-                                function: {
-                                    arguments: serializeToolArguments(toolInput),
-                                    name: toolName,
-                                },
-                                id: toolCallId,
-                                type: "function",
-                            },
-                        ],
-                    };
-                    continue;
-                }
-                if (eventType === "tool.finished") {
-                    if (normalizeText(record.subagentId)) {
-                        continue;
-                    }
-                    const toolCallId = normalizeText(record.toolCallId) || "tool";
-                    const output = toolOutputFromEvent(record.output);
-                    yield {
-                        content: output.content,
-                        metadata: output.structuredContent
-                            ? { structuredContent: output.structuredContent }
-                            : undefined,
-                        role: "tool",
-                        tool_call_id: toolCallId,
-                    };
-                    continue;
-                }
-                if (eventType === "usage.updated") {
-                    yield {
-                        metadata: {
-                            ...(record.lastRequestBudget ? { lastRequestBudget: record.lastRequestBudget } : {}),
-                            originalEventType: "usage_refresh",
-                            ...(record.usage ? { usage: record.usage } : {}),
-                        },
-                        role: "assistant",
-                    };
-                    continue;
-                }
-                if (eventType === "action.required") {
-                    const kind = normalizeText(record.kind);
-                    if (kind === "tool_approval") {
-                        const toolCallId = normalizeText(record.toolCallId);
-                        pendingActions.set(sessionId, {
-                            actionId: normalizeText(record.actionId),
-                            kind: "tool_approval",
-                            toolCallId: toolCallId || undefined,
-                            toolName: normalizeText(record.toolName) || "tool",
-                        });
-                        yield {
-                            content: normalizeText(record.reason) || "Approval requested.",
-                            metadata: {
-                                approval_requested: true,
-                                available_scopes: Array.isArray(record.availableScopes)
-                                    ? record.availableScopes
-                                    : undefined,
-                                permission: record.permission,
-                                requires_action: true,
-                                risk_level: record.riskLevel,
-                                tool_call_id: toolCallId,
-                                tool_name: record.toolName,
-                            },
-                            role: "assistant",
-                        };
-                        yield makeDoneMessage({ stopReason: "approval_required" });
-                        return;
-                    }
-                    if (kind === "ask_user") {
-                        const toolCallId = normalizeText(record.toolCallId);
-                        pendingActions.set(sessionId, {
-                            actionId: normalizeText(record.actionId),
-                            kind: "ask_user",
-                            questions: record.questions ?? [],
-                            toolCallId: toolCallId || undefined,
-                            toolName: normalizeText(record.toolName) || "ask-user",
-                        });
-                        yield {
-                            content: "",
-                            metadata: {
-                                kind: "ask_user",
-                                questions: record.questions,
-                                requires_action: true,
-                                tool_call_id: toolCallId,
-                                tool_name: record.toolName,
-                            },
-                            role: "assistant",
-                        };
-                        yield makeDoneMessage({ stopReason: "action_required" });
-                        return;
-                    }
-                    continue;
-                }
-                if (eventType === "run.finished") {
-                    pendingActions.delete(sessionId);
-                    yield makeDoneMessage({
-                        stopReason: record.status === "interrupted" ? "interrupted" : "completed",
-                    });
-                    return;
-                }
-                if (eventType === "run.error") {
-                    pendingActions.delete(sessionId);
-                    yield makeDoneMessage({
-                        error: errorMessage(record.error),
-                        stopReason: "failed",
-                    });
-                    return;
-                }
-            }
-        }
-        catch (error) {
-            pendingActions.delete(sessionId);
-            yield makeDoneMessage({
-                error: errorMessage(error),
-                stopReason: "failed",
-            });
-        }
-    };
-    const agent = {
-        ...bridge.agent,
-        receiveMessage(messages, rawMetadata = {}) {
-            const source = receiveMessageStream(messages, rawMetadata);
-            const queue = createAsyncQueue({
-                onClose: () => {
-                    void source.return?.();
-                },
-            });
-            void (async () => {
-                try {
-                    for await (const message of source)
-                        queue.push(message);
-                }
-                finally {
-                    queue.close();
-                }
-            })();
-            return queue;
-        },
-    };
-    return {
-        ...bridge,
-        attachStore(store) {
-            bridge.attachStore(store);
-        },
-        agent,
-    };
-}
-//# sourceMappingURL=goatchain-adapter.js.map

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=index.d.ts.map