@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/heart/providers/openai-compatible.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpenAICompatibleProviderRuntime = createOpenAICompatibleProviderRuntime;
+const bundle_manifest_1 = require("../../mind/bundle-manifest");
+const runtime_1 = require("../../nerves/runtime");
+const error_classification_1 = require("./error-classification");
+const CANONICAL_BASE_URLS = {
+    "openai-compatible": "https://api.z.ai/api/paas/v4/",
+    "openai-compatible-gemini": "https://generativelanguage.googleapis.com/v1beta/openai/",
+};
+function canonicalBaseUrl(provider, value) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new Error(`${provider} requires its canonical base URL`);
+    }
+    const normalized = parsed.toString().replace(/\/+$/u, "/");
+    const normalizedInput = value.replace(/\/+$/u, "/");
+    if (normalizedInput !== CANONICAL_BASE_URLS[provider] || normalized !== CANONICAL_BASE_URLS[provider]) {
+        throw new Error(`${provider} requires its canonical base URL ${CANONICAL_BASE_URLS[provider]}`);
+    }
+    return normalized;
+}
+function safeError(error, apiKey) {
+    const redact = (value) => value.split(apiKey).join("[redacted]");
+    const message = redact(error instanceof Error ? error.message : String(error));
+    const safe = new Error(message);
+    if (error instanceof Error) {
+        const source = error;
+        if (typeof source.status === "number" && Number.isFinite(source.status))
+            safe.status = source.status;
+        if (typeof source.code === "string")
+            safe.code = redact(source.code);
+    }
+    return safe;
+}
+function requiredString(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0)
+        throw new Error(`OpenAI-compatible response ${label} is missing`);
+    return value;
+}
+function parseUsage(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const usage = value;
+    const input = usage.prompt_tokens;
+    const output = usage.completion_tokens;
+    const total = usage.total_tokens;
+    if (![input, output, total].every((entry) => Number.isSafeInteger(entry) && entry >= 0))
+        return undefined;
+    const details = usage.completion_tokens_details;
+    const reasoning = details && typeof details === "object" && !Array.isArray(details)
+        && Number.isSafeInteger(details.reasoning_tokens)
+        ? Number(details.reasoning_tokens)
+        : 0;
+    return { input_tokens: Number(input), output_tokens: Number(output), reasoning_tokens: reasoning, total_tokens: Number(total) };
+}
+function parseCompletion(value, callbacks) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("OpenAI-compatible response envelope is invalid");
+    const choices = value.choices;
+    if (!Array.isArray(choices) || choices.length !== 1 || !choices[0] || typeof choices[0] !== "object") {
+        throw new Error("OpenAI-compatible response must contain exactly one choice");
+    }
+    const choice = choices[0];
+    const message = choice.message;
+    if (!message || typeof message !== "object" || Array.isArray(message))
+        throw new Error("OpenAI-compatible choice message is invalid");
+    const record = message;
+    if (Object.prototype.hasOwnProperty.call(record, "function_call")) {
+        throw new Error("OpenAI-compatible legacy function_call is unsupported");
+    }
+    const rawCalls = record.tool_calls;
+    const calls = rawCalls === undefined || rawCalls === null ? [] : rawCalls;
+    if (!Array.isArray(calls))
+        throw new Error("OpenAI-compatible tool_calls must be an array");
+    const toolCalls = calls.map((call) => {
+        if (!call || typeof call !== "object" || Array.isArray(call))
+            throw new Error("OpenAI-compatible tool call is invalid");
+        const callRecord = call;
+        const fn = callRecord.function;
+        if (callRecord.type !== "function" || !fn || typeof fn !== "object" || Array.isArray(fn)) {
+            throw new Error("OpenAI-compatible tool call must be a function");
+        }
+        return {
+            id: requiredString(callRecord.id, "tool call id"),
+            name: requiredString(fn.name, "tool name"),
+            arguments: requiredString(fn.arguments, "tool arguments"),
+        };
+    });
+    const content = typeof record.content === "string" ? record.content : "";
+    if (choice.finish_reason === "stop") {
+        if (toolCalls.length !== 0 || content.trim().length === 0)
+            throw new Error("OpenAI-compatible stop response shape is invalid");
+    }
+    else if (choice.finish_reason === "tool_calls") {
+        if (toolCalls.length < 1 || toolCalls.length > 8 || content.trim().length !== 0) {
+            throw new Error("OpenAI-compatible tool_calls response shape is invalid");
+        }
+    }
+    else {
+        throw new Error("OpenAI-compatible finish_reason is unsupported");
+    }
+    callbacks.onModelStreamStart();
+    if (content)
+        callbacks.onTextChunk(content);
+    return {
+        content,
+        toolCalls,
+        outputItems: [],
+        usage: parseUsage(value.usage),
+    };
+}
+function createOpenAICompatibleProviderRuntime(provider, model, config, deps = {}) {
+    const apiKey = config.apiKey?.trim();
+    if (!apiKey)
+        throw new Error(`provider '${provider}' is selected but apiKey is missing in the agent vault`);
+    const baseUrl = canonicalBaseUrl(provider, config.baseUrl);
+    const fetchImpl = deps.fetch ?? fetch;
+    const packageVersion = deps.packageVersion ?? (0, bundle_manifest_1.getPackageVersion)();
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.provider_init",
+        message: "OpenAI-compatible provider init",
+        meta: { provider },
+    });
+    const request = async (messages, tools, signal, toolChoiceRequired = false) => {
+        const body = { model, messages, tools, stream: false };
+        if (provider === "openai-compatible")
+            body.temperature = 0;
+        if (toolChoiceRequired)
+            body.tool_choice = "required";
+        try {
+            const response = await fetchImpl(new URL("chat/completions", baseUrl), {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    "Content-Type": "application/json",
+                    ...(provider === "openai-compatible-gemini"
+                        ? { "x-goog-api-client": `ouroboros-harness-oai/${packageVersion}` }
+                        : {}),
+                },
+                body: JSON.stringify(body),
+                signal,
+            });
+            if (!response.ok)
+                throw Object.assign(new Error(`provider request failed with HTTP ${response.status}`), { status: response.status });
+            return await response.json();
+        }
+        catch (error) {
+            throw safeError(error, apiKey);
+        }
+    };
+    return {
+        id: provider,
+        model,
+        client: { baseUrl },
+        capabilities: new Set(),
+        resetTurnState() { },
+        appendToolOutput() { },
+        async streamTurn(turnRequest) {
+            return parseCompletion(await request(turnRequest.messages, turnRequest.activeTools, turnRequest.signal, turnRequest.toolChoiceRequired), turnRequest.callbacks);
+        },
+        async ping(signal) {
+            const callbacks = {
+                onModelStreamStart() { },
+                onTextChunk() { },
+            };
+            parseCompletion(await request([{ role: "user", content: "ping" }], [], signal), callbacks);
+        },
+        classifyError(error) {
+            return (0, error_classification_1.classifyHttpError)(error);
+        },
+    };
+}

package/dist/heart/run-ledger.js

@@ -0,0 +1,247 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLedgerHash = runLedgerHash;
+exports.usageMetadataFromUsageData = usageMetadataFromUsageData;
+exports.deriveRunLedgerIds = deriveRunLedgerIds;
+exports.createRunLedgerRecord = createRunLedgerRecord;
+exports.runLedgerPath = runLedgerPath;
+exports.appendRunLedgerRecord = appendRunLedgerRecord;
+exports.appendRunLedgerRecordNonFatal = appendRunLedgerRecordNonFatal;
+exports.readRunLedger = readRunLedger;
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+function sha256Hex(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
+}
+function canonicalJson(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => canonicalJson(entry)).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function hashValue(value) {
+    return sha256Hex(canonicalJson(value));
+}
+function runLedgerHash(value) {
+    return `sha256:${hashValue(value)}`;
+}
+function stableUnique(values) {
+    return [...new Set((values ?? []).filter((value) => typeof value === "string" && value.trim().length > 0))];
+}
+function numberOrZero(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function usageMetadataFromUsageData(usage, source) {
+    return {
+        source,
+        inputTokens: numberOrZero(usage?.input_tokens),
+        outputTokens: numberOrZero(usage?.output_tokens),
+        reasoningTokens: numberOrZero(usage?.reasoning_tokens),
+        totalTokens: numberOrZero(usage?.total_tokens),
+    };
+}
+function deriveRunLedgerIds(input) {
+    const targetHash = runLedgerHash(input.target);
+    const idempotencyKey = `idem_${hashValue({
+        agent: input.agent,
+        triggerType: input.triggerType,
+        sourceKind: input.sourceKind,
+        senseOrHabit: input.senseOrHabit,
+        scope: input.idempotencyScope ?? input.target,
+    }).slice(0, 32)}`;
+    const runId = `run_${hashValue({
+        agent: input.agent,
+        triggerType: input.triggerType,
+        sourceKind: input.sourceKind,
+        senseOrHabit: input.senseOrHabit,
+        targetHash,
+        idempotencyKey,
+        parentRunId: input.parentRunId ?? null,
+    }).slice(0, 24)}`;
+    return {
+        runId,
+        rootRunId: input.rootRunId ?? input.parentRunId ?? runId,
+        ...(input.parentRunId ? { parentRunId: input.parentRunId } : {}),
+        idempotencyKey,
+        targetHash,
+    };
+}
+function createRunLedgerRecord(input) {
+    const ids = deriveRunLedgerIds(input);
+    return {
+        schemaVersion: 1,
+        recordedAt: new Date().toISOString(),
+        ...ids,
+        agent: input.agent,
+        triggerType: input.triggerType,
+        sourceKind: input.sourceKind,
+        senseOrHabit: input.senseOrHabit,
+        lifecycle: input.lifecycle,
+        startedAt: input.startedAt,
+        ...(input.endedAt ? { endedAt: input.endedAt } : {}),
+        ...(input.usage ? { usage: input.usage } : {}),
+        ...(input.provider ? { provider: input.provider } : {}),
+        ...(input.model ? { model: input.model } : {}),
+        ...(input.sessionRef ? { sessionRef: input.sessionRef } : {}),
+        contextPacketIds: stableUnique(input.contextPacketIds),
+        contentStored: false,
+        ...(input.errorName ? { errorName: input.errorName } : {}),
+        ...(input.errorCode ? { errorCode: input.errorCode } : {}),
+    };
+}
+function runLedgerPath(agentRoot) {
+    return path.join(agentRoot, "state", "run-ledger", "runs.jsonl");
+}
+function appendRunLedgerRecord(agentRoot, record) {
+    const filePath = runLedgerPath(agentRoot);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.appendFileSync(filePath, `${JSON.stringify(record)}\n`, "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.run_ledger_recorded",
+        message: "recorded causal run ledger row",
+        meta: {
+            agent: record.agent,
+            runId: record.runId,
+            triggerType: record.triggerType,
+            sourceKind: record.sourceKind,
+            lifecycle: record.lifecycle,
+            senseOrHabit: record.senseOrHabit,
+        },
+    });
+}
+function appendRunLedgerRecordNonFatal(agentRoot, record) {
+    try {
+        appendRunLedgerRecord(agentRoot, record);
+        return true;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "heart",
+            event: "heart.run_ledger_record_error",
+            message: "failed to record causal run ledger row",
+            meta: {
+                agent: record.agent,
+                runId: record.runId,
+                lifecycle: record.lifecycle,
+                error: String(error),
+            },
+        });
+        return false;
+    }
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function isUsageMetadata(value) {
+    const usage = value;
+    return !!usage
+        && (usage.source === "provider" || usage.source === "none" || usage.source === "reported-unavailable")
+        && typeof usage.inputTokens === "number"
+        && typeof usage.outputTokens === "number"
+        && typeof usage.reasoningTokens === "number"
+        && typeof usage.totalTokens === "number";
+}
+function isSessionRef(value) {
+    const ref = value;
+    return !!ref
+        && typeof ref.channel === "string"
+        && typeof ref.keyHash === "string";
+}
+function isRunLedgerRecord(value) {
+    const record = value;
+    return !!record
+        && record.schemaVersion === 1
+        && typeof record.recordedAt === "string"
+        && typeof record.runId === "string"
+        && typeof record.rootRunId === "string"
+        && (record.parentRunId === undefined || typeof record.parentRunId === "string")
+        && typeof record.idempotencyKey === "string"
+        && typeof record.agent === "string"
+        && (record.triggerType === "inbound" || record.triggerType === "habit" || record.triggerType === "reload" || record.triggerType === "recovery" || record.triggerType === "manual")
+        && (record.sourceKind === "sense" || record.sourceKind === "private-runtime" || record.sourceKind === "daemon" || record.sourceKind === "cli")
+        && typeof record.senseOrHabit === "string"
+        && typeof record.targetHash === "string"
+        && (record.lifecycle === "started" || record.lifecycle === "completed" || record.lifecycle === "skipped" || record.lifecycle === "blocked" || record.lifecycle === "error")
+        && typeof record.startedAt === "string"
+        && (record.endedAt === undefined || typeof record.endedAt === "string")
+        && (record.usage === undefined || isUsageMetadata(record.usage))
+        && (record.provider === undefined || typeof record.provider === "string")
+        && (record.model === undefined || typeof record.model === "string")
+        && (record.sessionRef === undefined || isSessionRef(record.sessionRef))
+        && isStringArray(record.contextPacketIds)
+        && record.contentStored === false
+        && (record.errorName === undefined || typeof record.errorName === "string")
+        && (record.errorCode === undefined || typeof record.errorCode === "string");
+}
+function emitMalformedRunLedgerRow(lineNumber, reason) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "heart",
+        event: "heart.run_ledger_malformed",
+        message: "skipped malformed causal run ledger row",
+        meta: { lineNumber, reason },
+    });
+}
+function readRunLedger(agentRoot) {
+    const filePath = runLedgerPath(agentRoot);
+    if (!fs.existsSync(filePath))
+        return [];
+    const rows = [];
+    const lines = fs.readFileSync(filePath, "utf-8").split("\n").filter((line) => line.trim().length > 0);
+    lines.forEach((line, index) => {
+        try {
+            const parsed = JSON.parse(line);
+            if (isRunLedgerRecord(parsed)) {
+                rows.push(parsed);
+            }
+            else {
+                emitMalformedRunLedgerRow(index + 1, "invalid shape");
+            }
+        }
+        catch (error) {
+            emitMalformedRunLedgerRow(index + 1, String(error));
+        }
+    });
+    return rows;
+}

package/dist/heart/runtime-capability-check.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyPerplexityCapability = verifyPerplexityCapability;
+exports.verifyEmbeddingsCapability = verifyEmbeddingsCapability;
+const runtime_1 = require("../nerves/runtime");
+function sanitizeCapabilityError(message) {
+    const statusMatch = message.match(/^(\d{3})\s/);
+    if (!statusMatch)
+        return message;
+    const status = statusMatch[1];
+    const body = message.slice(status.length).trim();
+    if (body.startsWith("<") || body.includes("<!DOCTYPE") || body.includes("<html")) {
+        return `HTTP ${status}`;
+    }
+    if (body.startsWith("{")) {
+        try {
+            const json = JSON.parse(body);
+            const inner = json?.error?.message;
+            if (typeof inner === "string" && inner && inner !== "Error") {
+                return `${status} ${inner}`;
+            }
+        }
+        catch {
+            // Keep the HTTP status fallback below.
+        }
+        return `HTTP ${status}`;
+    }
+    return message;
+}
+async function readHttpFailureSummary(response) {
+    let detail = `${response.status} ${response.statusText}`.trim();
+    try {
+        const json = await response.json();
+        if (typeof json.error === "string" && json.error.trim()) {
+            detail = `${response.status} ${json.error}`;
+        }
+        else if (typeof json.error === "object" && json.error !== null) {
+            const errObj = json.error;
+            if (typeof errObj.message === "string" && errObj.message.trim()) {
+                detail = `${response.status} ${errObj.message}`;
+            }
+        }
+        else if (typeof json.message === "string" && json.message.trim()) {
+            detail = `${response.status} ${json.message}`;
+        }
+    }
+    catch {
+        // Keep the HTTP status summary if the body is not JSON.
+    }
+    return sanitizeCapabilityError(detail);
+}
+function reportRuntimeCapabilityCheckStart(capability, url) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.runtime_capability_check_start",
+        message: "starting runtime capability check",
+        meta: { capability, url },
+    });
+}
+function reportRuntimeCapabilityCheckEnd(capability, url) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.runtime_capability_check_end",
+        message: "runtime capability check passed",
+        meta: { capability, url },
+    });
+}
+function reportRuntimeCapabilityCheckError(capability, url, summary) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "daemon",
+        event: "daemon.runtime_capability_check_error",
+        message: "runtime capability check failed",
+        meta: { capability, url, summary },
+    });
+}
+async function verifyPerplexityCapability(apiKey, fetchImpl = fetch) {
+    const url = "https://api.perplexity.ai/search";
+    reportRuntimeCapabilityCheckStart("perplexity-search", url);
+    try {
+        const response = await fetchImpl(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                query: "ping",
+                max_results: 1,
+            }),
+        });
+        if (!response.ok) {
+            const summary = await readHttpFailureSummary(response);
+            reportRuntimeCapabilityCheckError("perplexity-search", url, summary);
+            return {
+                ok: false,
+                summary,
+            };
+        }
+        const payload = await response.json();
+        if (!Array.isArray(payload.results) || payload.results.length === 0) {
+            const summary = "Perplexity returned no search results";
+            reportRuntimeCapabilityCheckError("perplexity-search", url, summary);
+            return {
+                ok: false,
+                summary,
+            };
+        }
+        reportRuntimeCapabilityCheckEnd("perplexity-search", url);
+        return {
+            ok: true,
+            summary: "live check passed",
+        };
+    }
+    catch (error) {
+        const summary = sanitizeCapabilityError(error instanceof Error ? error.message : String(error));
+        reportRuntimeCapabilityCheckError("perplexity-search", url, summary);
+        return {
+            ok: false,
+            summary,
+        };
+    }
+}
+async function verifyEmbeddingsCapability(apiKey, fetchImpl = fetch) {
+    const url = "https://api.openai.com/v1/embeddings";
+    reportRuntimeCapabilityCheckStart("memory-embeddings", url);
+    try {
+        const response = await fetchImpl(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                model: "text-embedding-3-small",
+                input: ["ping"],
+            }),
+        });
+        if (!response.ok) {
+            const summary = await readHttpFailureSummary(response);
+            reportRuntimeCapabilityCheckError("memory-embeddings", url, summary);
+            return {
+                ok: false,
+                summary,
+            };
+        }
+        const payload = await response.json();
+        if (!Array.isArray(payload.data) || payload.data.length !== 1 || !Array.isArray(payload.data[0]?.embedding) || payload.data[0].embedding.length === 0) {
+            const summary = "embeddings response missing expected vectors";
+            reportRuntimeCapabilityCheckError("memory-embeddings", url, summary);
+            return {
+                ok: false,
+                summary,
+            };
+        }
+        reportRuntimeCapabilityCheckEnd("memory-embeddings", url);
+        return {
+            ok: true,
+            summary: "live check passed",
+        };
+    }
+    catch (error) {
+        const summary = sanitizeCapabilityError(error instanceof Error ? error.message : String(error));
+        reportRuntimeCapabilityCheckError("memory-embeddings", url, summary);
+        return {
+            ok: false,
+            summary,
+        };
+    }
+}