@ouro.bot/cli 0.1.0-alpha.354 → 0.1.0-alpha.356

package/changelog.json

@@ -1,6 +1,18 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.356",
+      "changes": [
+        "Provider ping for github-copilot GPT models (e.g. gpt-5.4) now uses the Responses API instead of chat completions, fixing `400 Unsupported parameter: 'max_tokens'` errors during live checks."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.355",
+      "changes": [
+        "`ouro up` AI-assisted repair diagnosis now uses the same discovered and pinged provider credentials as provider readiness checks, including the machine-wide credential pool, instead of drifting back through the current agent's configured provider registry path."
+      ]
+    },
     {
       "version": "0.1.0-alpha.354",
       "changes": [

package/dist/heart/daemon/agentic-repair.js

@@ -7,8 +7,10 @@
  * This is a lightweight integration: one diagnostic LLM call, not a chat loop.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgenticDiagnosisProviderRuntime = createAgenticDiagnosisProviderRuntime;
 exports.runAgenticRepair = runAgenticRepair;
 const runtime_1 = require("../../nerves/runtime");
+const provider_ping_1 = require("../provider-ping");
 function buildSystemPrompt(degraded) {
     const agentList = degraded
         .map((d) => `- ${d.agent}: error="${d.errorReason}", hint="${d.fixHint}"`)
@@ -48,9 +50,22 @@ function makeInteractiveRepairDeps(deps) {
         runAuthFlow: deps.runAuthFlow ?? (async () => undefined),
     };
 }
+function discoveredProviderModel(provider) {
+    const model = provider.providerConfig.model?.trim();
+    return model ? model : undefined;
+}
+function createAgenticDiagnosisProviderRuntime(provider) {
+    const config = {
+        ...provider.providerConfig,
+        ...provider.credentials,
+    };
+    return (0, provider_ping_1.createProviderRuntimeForConfig)(provider.provider, config, {
+        model: discoveredProviderModel(provider),
+    });
+}
 async function tryAgenticDiagnosis(degraded, provider, deps) {
     const logsTail = deps.readDaemonLogsTail();
-    const runtime = deps.createProviderRuntime(provider.provider, provider.credentials);
+    const runtime = deps.createProviderRuntime(provider);
     const systemPrompt = buildSystemPrompt(degraded);
     const userMessage = buildUserMessage(degraded, logsTail);
     const messages = [

package/dist/heart/daemon/cli-exec.js

@@ -1529,13 +1529,7 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
                             secretsRoot: deps.secretsRoot ?? `${process.env["HOME"]}/.agentsecrets`,
                         });
                     },
-                    createProviderRuntime: (provider, _credentials) => {
-                        const { createProviderRegistry } = require("../core");
-                        const runtime = createProviderRegistry().resolve(provider);
-                        if (!runtime)
-                            throw new Error(`failed to create runtime for ${provider}`);
-                        return runtime;
-                    },
+                    createProviderRuntime: agentic_repair_1.createAgenticDiagnosisProviderRuntime,
                     readDaemonLogsTail: () => {
                         try {
                             const fs = require("node:fs");

package/dist/heart/daemon/provider-discovery.js

@@ -2,13 +2,14 @@
 /**
  * Shared provider discovery — single path for finding a working LLM provider.
  *
- * Scans disk credentials and environment variables, deduplicates by provider
- * (disk first), then pings each candidate to validate credentials actually work.
+ * Scans machine-pool credentials, legacy disk credentials, and environment variables,
+ * deduplicates by provider, then pings each candidate to validate credentials actually work.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanEnvVarCredentials = scanEnvVarCredentials;
 exports.discoverWorkingProvider = discoverWorkingProvider;
 const identity_1 = require("../identity");
+const provider_credential_pool_1 = require("../provider-credential-pool");
 const runtime_1 = require("../../nerves/runtime");
 /**
  * Scan environment variables for API keys using the canonical PROVIDER_CREDENTIALS descriptor.
@@ -37,16 +38,50 @@ function scanEnvVarCredentials(env) {
     }
     return results;
 }
+function stringifyProviderFields(fields) {
+    const result = {};
+    for (const [key, value] of Object.entries(fields)) {
+        result[key] = String(value);
+    }
+    return result;
+}
+function machinePoolSource(record) {
+    if (record.provenance.contributedByAgent) {
+        return `machine-pool:${record.provenance.contributedByAgent}`;
+    }
+    return `machine-pool:${record.provenance.source}`;
+}
+function discoverMachinePoolCredentials(secretsRoot) {
+    const homeDir = (0, provider_credential_pool_1.providerCredentialHomeDirFromSecretsRoot)(secretsRoot);
+    const poolResult = (0, provider_credential_pool_1.readProviderCredentialPool)(homeDir);
+    if (!poolResult.ok)
+        return [];
+    const credentials = [];
+    for (const [, record] of Object.entries(poolResult.pool.providers)) {
+        credentials.push({
+            provider: record.provider,
+            agentName: machinePoolSource(record),
+            credentials: stringifyProviderFields(record.credentials),
+            providerConfig: stringifyProviderFields(record.config),
+        });
+    }
+    return credentials;
+}
 /**
- * Discover the first working provider by scanning disk credentials and env vars,
- * deduplicating by provider (disk first), and pinging each candidate.
+ * Discover the first working provider by scanning configured credential sources,
+ * deduplicating by provider, and pinging each candidate.
  */
 async function discoverWorkingProvider(deps) {
+    const poolCreds = discoverMachinePoolCredentials(deps.secretsRoot);
     const diskCreds = deps.discoverExistingCredentials(deps.secretsRoot);
     const envCreds = scanEnvVarCredentials(deps.env);
-    // Deduplicate: disk credentials first, env vars as fallback for providers not on disk
+    // Deduplicate: machine pool first, legacy per-agent disk next, env vars last.
     const seenProviders = new Set();
     const candidates = [];
+    for (const cred of poolCreds) {
+        seenProviders.add(cred.provider);
+        candidates.push(cred);
+    }
     for (const cred of diskCreds) {
         if (!seenProviders.has(cred.provider)) {
             seenProviders.add(cred.provider);
@@ -64,7 +99,7 @@ async function discoverWorkingProvider(deps) {
             level: "info",
             component: "daemon",
             event: "daemon.provider_discovery_none",
-            message: "no provider credentials found on disk or in environment",
+            message: "no provider credentials found in machine pool, legacy disk, or environment",
             meta: {},
         });
         return null;

package/dist/heart/provider-ping.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sanitizeErrorMessage = sanitizeErrorMessage;
 exports.pingGithubCopilotModel = pingGithubCopilotModel;
+exports.createProviderRuntimeForConfig = createProviderRuntimeForConfig;
 exports.pingProvider = pingProvider;
 exports.runHealthInventory = runHealthInventory;
 const identity_1 = require("./identity");
@@ -136,11 +137,11 @@ function hasEmptyCredentials(provider, config) {
     }
     return identity_1.PROVIDER_CREDENTIALS[provider].required.some((key) => !record[key]);
 }
-function createRuntimeForPing(provider, config, model) {
+function createProviderRuntimeForConfig(provider, config, options = {}) {
     // 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 resolvedModel = model ?? (0, provider_models_1.getDefaultModelForProvider)(provider);
+    const resolvedModel = options.model ?? (0, provider_models_1.getDefaultModelForProvider)(provider);
     switch (provider) {
         case "anthropic":
             return (0, anthropic_1.createAnthropicProviderRuntime)(resolvedModel, config);
@@ -166,7 +167,7 @@ async function pingProvider(provider, config, options = {}) {
     }
     let runtime;
     try {
-        runtime = createRuntimeForPing(provider, config, options.model);
+        runtime = createProviderRuntimeForConfig(provider, config, { model: options.model });
         /* v8 ignore start -- factory creation failure: tested via individual provider init tests @preserve */
     }
     catch (error) {
@@ -212,8 +213,13 @@ async function pingProvider(provider, config, options = {}) {
                         toolChoiceRequired: false,
                     });
                 }
+                else if (provider === "github-copilot" && !runtime.model.startsWith("claude")) {
+                    // GPT models on Copilot use the Responses API
+                    const client = runtime.client;
+                    await client.responses.create(createResponsePingRequest(runtime.model), { signal: controller.signal });
+                }
                 else {
-                    // OpenAI-compatible providers (azure, minimax, github-copilot)
+                    // OpenAI-compatible providers (azure, minimax, github-copilot claude)
                     const client = runtime.client;
                     await client.chat.completions.create(createChatPingRequest(runtime.model), { signal: controller.signal });
                 }

package/package.json

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