@ouro.bot/cli 0.1.0-alpha.347 → 0.1.0-alpha.349

package/dist/heart/provider-attempt.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PROVIDER_ATTEMPT_POLICY = exports.ProviderAttemptAbortError = void 0;
+exports.runProviderAttempt = runProviderAttempt;
+const runtime_1 = require("../nerves/runtime");
+class ProviderAttemptAbortError extends Error {
+    constructor(message = "provider attempt aborted") {
+        super(message);
+        this.name = "ProviderAttemptAbortError";
+    }
+}
+exports.ProviderAttemptAbortError = ProviderAttemptAbortError;
+exports.DEFAULT_PROVIDER_ATTEMPT_POLICY = {
+    maxAttempts: 3,
+    baseDelayMs: 2_000,
+    backoffMultiplier: 2,
+};
+function sleep(delayMs) {
+    return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+function normalizePolicy(policy) {
+    return {
+        ...exports.DEFAULT_PROVIDER_ATTEMPT_POLICY,
+        ...policy,
+    };
+}
+function toError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function classify(error, classifyError) {
+    if (!(error instanceof Error))
+        return "unknown";
+    try {
+        return classifyError(error);
+    }
+    catch {
+        return "unknown";
+    }
+}
+function httpStatus(error) {
+    const status = error.status;
+    return typeof status === "number" ? status : null;
+}
+function delayForAttempt(policy, attempt) {
+    return policy.baseDelayMs * Math.pow(policy.backoffMultiplier, attempt - 1);
+}
+async function runProviderAttempt(input) {
+    const policy = normalizePolicy(input.policy);
+    const maxAttempts = Math.max(1, Math.floor(policy.maxAttempts));
+    const wait = input.sleep ?? sleep;
+    const attempts = [];
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            const value = await input.run();
+            attempts.push({
+                attempt,
+                provider: input.provider,
+                model: input.model,
+                operation: input.operation,
+                ok: true,
+                willRetry: false,
+            });
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.provider_attempt_succeeded",
+                message: "provider attempt succeeded",
+                meta: { provider: input.provider, model: input.model, operation: input.operation, attempt, maxAttempts },
+            });
+            return { ok: true, value, attempts };
+        }
+        catch (caught) {
+            if (caught instanceof ProviderAttemptAbortError)
+                throw caught;
+            const error = toError(caught);
+            const classification = classify(caught, input.classifyError);
+            const willRetry = attempt < maxAttempts;
+            const delayMs = willRetry ? delayForAttempt(policy, attempt) : undefined;
+            const record = {
+                attempt,
+                provider: input.provider,
+                model: input.model,
+                operation: input.operation,
+                ok: false,
+                classification,
+                errorMessage: error.message,
+                httpStatus: httpStatus(error),
+                willRetry,
+                ...(delayMs !== undefined ? { delayMs } : {}),
+            };
+            attempts.push(record);
+            if (!willRetry) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "engine",
+                    event: "engine.provider_attempt_failed",
+                    message: "provider attempt failed",
+                    meta: {
+                        provider: input.provider,
+                        model: input.model,
+                        operation: input.operation,
+                        attempt,
+                        maxAttempts,
+                        classification,
+                        errorMessage: error.message.slice(0, 200),
+                        httpStatus: httpStatus(error),
+                    },
+                });
+                return { ok: false, error, classification, attempts };
+            }
+            const retryDelayMs = delayMs;
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.provider_attempt_retry",
+                message: "provider attempt failed; retrying",
+                meta: {
+                    provider: input.provider,
+                    model: input.model,
+                    operation: input.operation,
+                    attempt,
+                    maxAttempts,
+                    classification,
+                    errorMessage: error.message.slice(0, 200),
+                    httpStatus: httpStatus(error),
+                    delayMs: retryDelayMs,
+                },
+            });
+            await input.onRetry?.(record, maxAttempts);
+            await wait(retryDelayMs);
+        }
+    }
+    /* v8 ignore next 2 -- defensive: loop always returns on success or final failure @preserve */
+    return { ok: false, error: new Error("provider attempt loop ended unexpectedly"), classification: "unknown", attempts };
+}

package/dist/heart/provider-credential-pool.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitProviderCredentialFields = splitProviderCredentialFields;
 exports.getProviderCredentialPoolPath = getProviderCredentialPoolPath;
 exports.validateProviderCredentialPool = validateProviderCredentialPool;
 exports.readProviderCredentialPool = readProviderCredentialPool;
@@ -105,7 +106,7 @@ function copyKnownFields(source, fields) {
     }
     return result;
 }
-function splitLegacyProviderConfig(provider, rawConfig) {
+function splitProviderCredentialFields(provider, rawConfig) {
     const fields = PROVIDER_FIELD_SPLITS[provider];
     return {
         credentials: copyKnownFields(rawConfig, fields.credentials),
@@ -336,7 +337,7 @@ function readLegacyAgentProviderCredentials(input) {
         if (!legacyProviderHasCredentialData(providerKey, rawProviderConfig)) {
             continue;
         }
-        const { credentials, config } = splitLegacyProviderConfig(providerKey, rawProviderConfig);
+        const { credentials, config } = splitProviderCredentialFields(providerKey, rawProviderConfig);
         candidates.push({
             provider: providerKey,
             credentials,

package/dist/heart/provider-ping.js

@@ -13,6 +13,7 @@ const github_copilot_1 = require("./providers/github-copilot");
 const auth_flow_1 = require("./auth/auth-flow");
 const provider_models_1 = require("./provider-models");
 const runtime_1 = require("../nerves/runtime");
+const provider_attempt_1 = require("./provider-attempt");
 const PING_TIMEOUT_MS = 10_000;
 const PING_PROMPT = "ping";
 const CHAT_PING_MAX_TOKENS = 1;
@@ -67,6 +68,30 @@ function sanitizeErrorMessage(message) {
     // Already clean (e.g., "401 Provided authentication token is expired.")
     return message;
 }
+async function readGithubCopilotModelPingError(response) {
+    let detail = `HTTP ${response.status}`;
+    try {
+        const json = await response.json();
+        /* v8 ignore start -- error format parsing: all branches tested via config-models.test.ts @preserve */
+        if (typeof json.error === "string")
+            detail = json.error;
+        else if (typeof json.error === "object" && json.error !== null) {
+            const errObj = json.error;
+            if (typeof errObj.message === "string")
+                detail = errObj.message;
+        }
+        else if (typeof json.message === "string")
+            detail = json.message;
+        /* v8 ignore stop */
+    }
+    catch {
+        // response body not JSON — keep HTTP status
+    }
+    return detail;
+}
+function createStatusError(message, status) {
+    return Object.assign(new Error(message), { status });
+}
 async function pingGithubCopilotModel(baseUrl, token, model, fetchImpl = fetch) {
     const base = baseUrl.replace(/\/+$/, "");
     const isClaude = model.startsWith("claude");
@@ -74,41 +99,31 @@ async function pingGithubCopilotModel(baseUrl, token, model, fetchImpl = fetch)
     const body = isClaude
         ? JSON.stringify(createChatPingRequest(model))
         : JSON.stringify(createResponsePingRequest(model));
-    try {
-        const response = await fetchImpl(url, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${token}`,
-                "Content-Type": "application/json",
-            },
-            body,
-        });
-        if (response.ok)
-            return { ok: true };
-        let detail = `HTTP ${response.status}`;
-        try {
-            const json = await response.json();
-            /* v8 ignore start -- error format parsing: all branches tested via config-models.test.ts @preserve */
-            if (typeof json.error === "string")
-                detail = json.error;
-            else if (typeof json.error === "object" && json.error !== null) {
-                const errObj = json.error;
-                if (typeof errObj.message === "string")
-                    detail = errObj.message;
+    const attempt = await (0, provider_attempt_1.runProviderAttempt)({
+        operation: "model-ping",
+        provider: "github-copilot",
+        model,
+        classifyError: github_copilot_1.classifyGithubCopilotError,
+        policy: {
+            maxAttempts: 3,
+            baseDelayMs: 0,
+            backoffMultiplier: 2,
+        },
+        run: async () => {
+            const response = await fetchImpl(url, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                },
+                body,
+            });
+            if (!response.ok) {
+                throw createStatusError(await readGithubCopilotModelPingError(response), response.status);
             }
-            else if (typeof json.message === "string")
-                detail = json.message;
-            /* v8 ignore stop */
-        }
-        catch {
-            // response body not JSON — keep HTTP status
-        }
-        return { ok: false, error: detail };
-    }
-    catch (err) {
-        /* v8 ignore next -- defensive: fetch errors are always Error instances @preserve */
-        return { ok: false, error: err instanceof Error ? err.message : String(err) };
-    }
+        },
+    });
+    return attempt.ok ? { ok: true } : { ok: false, error: attempt.error.message };
 }
 function hasEmptyCredentials(provider, config) {
     const record = config;
@@ -121,37 +136,37 @@ function hasEmptyCredentials(provider, config) {
     }
     return identity_1.PROVIDER_CREDENTIALS[provider].required.some((key) => !record[key]);
 }
-function createRuntimeForPing(provider, config) {
+function createRuntimeForPing(provider, config, model) {
     // Use the same provider defaults as auth switch and hatch so verification
     // cannot drift to stale provider/model pairings, and pass the checked
     // credentials directly so daemon-side pings do not depend on --agent globals.
-    const model = (0, provider_models_1.getDefaultModelForProvider)(provider);
+    const resolvedModel = model ?? (0, provider_models_1.getDefaultModelForProvider)(provider);
     switch (provider) {
         case "anthropic":
-            return (0, anthropic_1.createAnthropicProviderRuntime)(model, config);
+            return (0, anthropic_1.createAnthropicProviderRuntime)(resolvedModel, config);
         case "azure":
-            return (0, azure_1.createAzureProviderRuntime)(model, {
+            return (0, azure_1.createAzureProviderRuntime)(resolvedModel, {
                 ...config,
                 apiVersion: config.apiVersion ?? DEFAULT_AZURE_API_VERSION,
             });
         case "minimax":
-            return (0, minimax_1.createMinimaxProviderRuntime)(model, config);
+            return (0, minimax_1.createMinimaxProviderRuntime)(resolvedModel, config);
         case "openai-codex":
-            return (0, openai_codex_1.createOpenAICodexProviderRuntime)(model, config);
+            return (0, openai_codex_1.createOpenAICodexProviderRuntime)(resolvedModel, config);
         case "github-copilot":
-            return (0, github_copilot_1.createGithubCopilotProviderRuntime)(model, config);
+            return (0, github_copilot_1.createGithubCopilotProviderRuntime)(resolvedModel, config);
         /* v8 ignore next 2 -- exhaustive: all providers handled above @preserve */
         default:
             throw new Error(`unsupported provider for ping: ${provider}`);
     }
 }
-async function pingProvider(provider, config) {
+async function pingProvider(provider, config, options = {}) {
     if (hasEmptyCredentials(provider, config)) {
         return { ok: false, classification: "auth-failure", message: "no credentials configured" };
     }
     let runtime;
     try {
-        runtime = createRuntimeForPing(provider, config);
+        runtime = createRuntimeForPing(provider, config, options.model);
         /* v8 ignore start -- factory creation failure: tested via individual provider init tests @preserve */
     }
     catch (error) {
@@ -162,58 +177,67 @@ async function pingProvider(provider, config) {
         };
     }
     /* v8 ignore stop */
-    try {
-        const controller = new AbortController();
-        /* v8 ignore next -- timeout callback: only fires after 10s, tests resolve faster @preserve */
-        const timeout = setTimeout(() => controller.abort(), PING_TIMEOUT_MS);
-        try {
-            // Minimal API call — no thinking, no reasoning, no tools.
-            if (provider === "anthropic") {
-                // Use haiku for the ping — setup tokens may not have access to newer
-                // models, but if haiku works, the credentials are valid.
-                // Override the beta header to exclude thinking (which requires a
-                // thinking param in the request body).
-                const client = runtime.client;
-                await client.messages.create(createChatPingRequest(ANTHROPIC_SETUP_PING_MODEL), { signal: controller.signal, headers: { "anthropic-beta": "claude-code-20250219,oauth-2025-04-20" } });
+    const attempt = await (0, provider_attempt_1.runProviderAttempt)({
+        operation: "ping",
+        provider,
+        model: runtime.model,
+        classifyError: (error) => runtime.classifyError(error),
+        policy: {
+            maxAttempts: 3,
+            baseDelayMs: 0,
+            backoffMultiplier: 2,
+            ...options.attemptPolicy,
+        },
+        sleep: options.sleep,
+        run: async () => {
+            const controller = new AbortController();
+            /* v8 ignore next -- timeout callback: only fires after 10s, tests resolve faster @preserve */
+            const timeout = setTimeout(() => controller.abort(), PING_TIMEOUT_MS);
+            try {
+                // Minimal API call — no thinking, no reasoning, no tools.
+                if (provider === "anthropic") {
+                    // Use haiku for the ping — setup tokens may not have access to newer
+                    // models, but if haiku works, the credentials are valid.
+                    // Override the beta header to exclude thinking (which requires a
+                    // thinking param in the request body).
+                    const client = runtime.client;
+                    await client.messages.create(createChatPingRequest(ANTHROPIC_SETUP_PING_MODEL), { signal: controller.signal, headers: { "anthropic-beta": "claude-code-20250219,oauth-2025-04-20" } });
+                }
+                else if (provider === "openai-codex") {
+                    await runtime.streamTurn({
+                        messages: createPingMessages(),
+                        activeTools: [],
+                        callbacks: PING_CALLBACKS,
+                        signal: controller.signal,
+                        toolChoiceRequired: false,
+                    });
+                }
+                else {
+                    // OpenAI-compatible providers (azure, minimax, github-copilot)
+                    const client = runtime.client;
+                    await client.chat.completions.create(createChatPingRequest(runtime.model), { signal: controller.signal });
+                }
             }
-            else if (provider === "openai-codex") {
-                await runtime.streamTurn({
-                    messages: createPingMessages(),
-                    activeTools: [],
-                    callbacks: PING_CALLBACKS,
-                    signal: controller.signal,
-                    toolChoiceRequired: false,
-                });
+            finally {
+                clearTimeout(timeout);
             }
-            else {
-                // OpenAI-compatible providers (azure, minimax, github-copilot)
-                const client = runtime.client;
-                await client.chat.completions.create(createChatPingRequest(runtime.model), { signal: controller.signal });
-            }
-            return { ok: true };
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-    }
-    catch (error) {
-        const err = error instanceof Error ? error : /* v8 ignore next -- defensive @preserve */ new Error(String(error));
-        let classification;
-        try {
-            classification = runtime.classifyError(err);
-        }
-        catch {
-            /* v8 ignore next -- defensive: classifyError should not throw @preserve */
-            classification = "unknown";
-        }
-        (0, runtime_1.emitNervesEvent)({
-            component: "engine",
-            event: "engine.provider_ping_fail",
-            message: `provider ping failed: ${provider}`,
-            meta: { provider, classification, error: err.message },
-        });
-        return { ok: false, classification, message: sanitizeErrorMessage(err.message) };
+        },
+    });
+    if (attempt.ok) {
+        return { ok: true, attempts: attempt.attempts };
     }
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.provider_ping_fail",
+        message: `provider ping failed: ${provider}`,
+        meta: { provider, classification: attempt.classification, error: attempt.error.message },
+    });
+    return {
+        ok: false,
+        classification: attempt.classification,
+        message: sanitizeErrorMessage(attempt.error.message),
+        attempts: attempt.attempts,
+    };
 }
 const PINGABLE_PROVIDERS = ["anthropic", "openai-codex", "azure", "minimax", "github-copilot"];
 async function runHealthInventory(agentName, currentProvider, deps = {}) {

package/dist/senses/trust-gate.js

@@ -104,6 +104,10 @@ function enforceTrustGate(input) {
         return { allowed: true };
     }
     // Open senses (BlueBubbles/iMessage) — enforce trust rules
+    // Group chat with a family member present — allow regardless of trust level
+    if (input.isGroupChat && input.groupHasFamilyMember) {
+        return { allowed: true };
+    }
     const trustLevel = input.friend.trustLevel ?? "friend";
     // Family and friend — always allow on open
     if ((0, types_1.isTrustedLevel)(trustLevel)) {
@@ -119,11 +123,7 @@ function enforceTrustGate(input) {
     return handleStranger(input, bundleRoot, nowIso);
 }
 function handleAcquaintance(input, bundleRoot, nowIso) {
-    const { isGroupChat, groupHasFamilyMember, hasExistingGroupWithFamily } = input;
-    // Group chat with family member present — allow
-    if (isGroupChat && groupHasFamilyMember) {
-        return { allowed: true };
-    }
+    const { isGroupChat, hasExistingGroupWithFamily } = input;
     let result;
     let noticeDetail;
     if (isGroupChat) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.347",
+  "version": "0.1.0-alpha.349",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",