nolo-cli 0.1.33 → 0.1.34

package/README.md

@@ -90,7 +90,7 @@ nolo chat
 nolo connect
 nolo connect --watch
 nolo connect --daemon
-nolo daemon --server-url https://api.nolo.chat --api-key sk_machine_xxx
+nolo daemon --server-url https://api.nolo.chat --machine-key sk_machine_xxx
 nolo machine status
 nolo run "summarize my latest agent dialogs"
 nolo doc create --title "Trip Notes" --body "hello" --sync local,us --dry-run
@@ -116,7 +116,7 @@ nolo connect          # send one machine heartbeat
 nolo connect --watch  # keep this terminal process online with periodic heartbeats
 nolo connect --ws     # keep a live connector websocket for bound agent runs
 nolo connect --daemon # start connect --ws silently in the background
-nolo daemon --server-url https://api.nolo.chat --api-key sk_machine_xxx
+nolo daemon --server-url https://api.nolo.chat --machine-key sk_machine_xxx
 nolo machine status   # list machines registered to the current profile
 ```
 
@@ -126,13 +126,13 @@ They do not expose shell, file-write, or raw local LLM endpoints.
 Run a Slock-style connector command:
 
 ```bash
-nolo daemon --server-url https://api.nolo.chat --api-key sk_machine_xxx
+nolo daemon --server-url https://api.nolo.chat --machine-key sk_machine_xxx
 ```
 
 Future published package shape:
 
 ```bash
-npx @nolo/daemon@latest --server-url https://api.nolo.chat --api-key sk_machine_xxx
+npx @nolo/daemon@latest --server-url https://api.nolo.chat --machine-key sk_machine_xxx
 ```
 
 The daemon registers this computer, reports local CLI capabilities, keeps a live

package/agent-runtime/agentRecordConfig.ts

@@ -64,6 +64,10 @@ export function resolveAgentRuntimeConfigFromRecord(
   const apiSource = stringField(record, "apiSource");
   const cliProvider = stringField(record, "cliProvider");
   const customProviderUrl = stringField(record, "customProviderUrl");
+  const apiKey = stringField(record, "apiKey");
+  const apiKeyHeader = stringField(record, "apiKeyHeader");
+  const apiKeyFromAgentKey = stringField(record, "apiKeyFromAgentKey");
+  const useServerProxy = record.useServerProxy === true;
   const provider = stringField(record, "provider") ?? stringField(record, "apiSource");
   const toolNames = resolveAgentRuntimeToolNames(record);
   const temperature = numberField(record, "temperature");
@@ -87,6 +91,10 @@ export function resolveAgentRuntimeConfigFromRecord(
     ...(apiSource ? { apiSource } : {}),
     ...(cliProvider ? { cliProvider } : {}),
     ...(customProviderUrl ? { customProviderUrl } : {}),
+    ...(apiKey ? { apiKey } : {}),
+    ...(apiKeyHeader ? { apiKeyHeader } : {}),
+    ...(apiKeyFromAgentKey ? { apiKeyFromAgentKey } : {}),
+    ...(useServerProxy ? { useServerProxy } : {}),
     ...(toolNames ? { toolNames } : {}),
     ...(temperature !== undefined ? { temperature } : {}),
     ...(topP !== undefined ? { top_p: topP } : {}),

package/agent-runtime/hostAdapter.ts

@@ -14,6 +14,10 @@ export type AgentRuntimeAgentConfig = {
   apiSource?: string;
   cliProvider?: string;
   customProviderUrl?: string;
+  apiKey?: string;
+  apiKeyHeader?: string;
+  apiKeyFromAgentKey?: string;
+  useServerProxy?: boolean;
   toolNames?: string[];
   temperature?: number;
   top_p?: number;
@@ -30,13 +34,17 @@ export type AgentRuntimeAgentConfig = {
 
 export type AgentRuntimeProvider = {
   model: string;
-  complete(messages: AgentRuntimeChatMessage[]): Promise<AgentRuntimeResult>;
+  complete(
+    messages: AgentRuntimeChatMessage[],
+    options?: { timeoutMs?: number }
+  ): Promise<AgentRuntimeResult>;
 };
 
 export type AgentRuntimeToolCallInput = {
   id: string;
   name: string;
   arguments: string;
+  userInput?: string;
 };
 
 export type AgentRuntimeToolResult = {

package/agent-runtime/index.ts

@@ -10,6 +10,11 @@ export {
   parseOpenAiCompatibleChatCompletionResponse,
 } from "./openAiCompatibleProvider";
 export { resolveOpenAiCompatibleProviderConfig } from "./openAiCompatibleProviderConfig";
+export {
+  buildProviderAuthHeaders,
+  buildProviderExecutionPlan,
+  resolveAgentProviderMode,
+} from "./providerResolution";
 export {
   buildPlatformChatCompletionRequest,
   canUsePlatformChatProvider,
@@ -45,9 +50,14 @@ export {
   executeLocalToolWithPolicy,
   resolveLocalToolPolicy,
 } from "./localToolPolicy";
+export {
+  evaluateShellCommandPolicy,
+  isDestructiveShellCommand,
+} from "./shellCommandPolicy";
 export {
   mergeAgentRuntimeToolPolicies,
   normalizeAgentRuntimeToolPolicy,
+  resolveRequestedRuntimeToolNames,
   resolveEffectiveRuntimeToolPolicy,
 } from "./runtimeToolPolicy";
 export {

package/agent-runtime/localLoop.ts

@@ -13,6 +13,7 @@ export type LocalAgentTurnInput = {
   input: AgentRuntimeMessageContent;
   continueDialogId?: string;
   maxToolRounds?: number;
+  timeoutMs?: number;
   onToolEvent?: (event: LocalAgentToolEvent) => void;
 };
 
@@ -40,6 +41,29 @@ function formatToolExecutionError(args: {
   return `${args.toolName} failed: ${message}`;
 }
 
+function formatStructuredToolExecutionError(args: {
+  toolName: string;
+  error: unknown;
+}) {
+  if (!args.error || typeof args.error !== "object") return null;
+  const error = args.error as {
+    code?: unknown;
+    message?: unknown;
+    policy?: unknown;
+  };
+  if (typeof error.code !== "string") return null;
+  return JSON.stringify({
+    error: error.code,
+    message:
+      typeof error.message === "string"
+        ? error.message
+        : formatToolExecutionError(args),
+    ...(error.policy && typeof error.policy === "object"
+      ? { policy: error.policy }
+      : {}),
+  });
+}
+
 function shouldReturnToolExecutionErrors(adapter: AgentRuntimeHostAdapter) {
   return adapter.capabilities.includes("local-tools");
 }
@@ -66,6 +90,16 @@ function buildMessages(args: {
   ];
 }
 
+function extractUserInputText(content: AgentRuntimeMessageContent): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((part) => (part?.type === "text" ? part.text : ""))
+    .filter(Boolean)
+    .join("\n")
+    .trim();
+}
+
 export async function runLocalAgentTurn(
   input: LocalAgentTurnInput
 ): Promise<LocalAgentTurnResult> {
@@ -92,10 +126,13 @@ export async function runLocalAgentTurn(
   });
   const provider = await input.adapter.resolveProvider(agentConfig);
   const maxToolRounds = input.maxToolRounds ?? DEFAULT_LOCAL_AGENT_MAX_TOOL_ROUNDS;
+  const userInputText = extractUserInputText(input.input);
   let toolCallCount = 0;
   let result: AgentRuntimeResult;
   for (let round = 0; round <= maxToolRounds; round += 1) {
-    result = await provider.complete(messages);
+    result = await provider.complete(messages, {
+      ...(typeof input.timeoutMs === "number" ? { timeoutMs: input.timeoutMs } : {}),
+    });
     const toolCalls = result.tool_calls ?? [];
     if (toolCalls.length === 0) break;
     if (round === maxToolRounds) {
@@ -122,6 +159,7 @@ export async function runLocalAgentTurn(
           id: toolCall.id,
           name: toolName,
           arguments: toolCall.function.arguments,
+          ...(userInputText ? { userInput: userInputText } : {}),
         });
         emitToolEvent(input, {
           type: "tool-result",
@@ -140,11 +178,20 @@ export async function runLocalAgentTurn(
           message: error instanceof Error ? error.message : String(error),
         });
         toolResult = {
-          content: formatToolExecutionError({ toolName, error }),
+          content:
+            formatStructuredToolExecutionError({ toolName, error }) ??
+            formatToolExecutionError({ toolName, error }),
           metadata: {
             error: true,
             toolName,
             message: error instanceof Error ? error.message : String(error),
+            ...(
+              error &&
+              typeof error === "object" &&
+              typeof (error as { code?: unknown }).code === "string"
+                ? { code: (error as { code: string }).code }
+                : {}
+            ),
           },
         };
       }

package/agent-runtime/localToolPolicy.ts

@@ -2,6 +2,8 @@ import type {
   AgentRuntimeToolCallInput,
   AgentRuntimeToolResult,
 } from "./types";
+import { canonicalizeToolName } from "../ai/tools/toolNameAliases";
+import { evaluateShellCommandPolicy } from "./shellCommandPolicy";
 
 type EnvLike = Record<string, string | undefined>;
 
@@ -48,6 +50,22 @@ function parseToolAllowlist(value: string | undefined) {
     .filter(Boolean);
 }
 
+function normalizeLocalToolName(toolName: string) {
+  return canonicalizeToolName(
+    String(toolName ?? "").replace(/^functions\./, "").trim(),
+  );
+}
+
+function parseShellCommandPayload(rawArguments: string) {
+  try {
+    const parsed = JSON.parse(rawArguments || "{}");
+    if (!parsed || typeof parsed !== "object") return {};
+    return parsed as { command?: unknown; cmd?: unknown; input?: unknown };
+  } catch {
+    return {};
+  }
+}
+
 function isLocalShellModeEnabled(env: EnvLike) {
   return ["worktree", "dangerous", "1", "true"].includes(env.NOLO_LOCAL_SHELL_MODE || "");
 }
@@ -72,51 +90,62 @@ export function resolveLocalToolPolicy(args: {
   agentToolNames?: string[];
   toolName: string;
 }): LocalToolPolicyDecision {
+  const toolName = normalizeLocalToolName(args.toolName);
   const restrictedMode = isRestrictedLocalToolMode(args.env);
-  if (args.toolName === "execShell") {
+  if (!toolName) {
+    return {
+      allowed: false,
+      toolName,
+      reason: "Tool name is required.",
+    };
+  }
+
+  if (toolName === "execShell") {
     if (isLocalShellModeEnabled(args.env)) {
-      return { allowed: true, toolName: args.toolName };
+      return { allowed: true, toolName };
     }
     return {
       allowed: false,
-      toolName: args.toolName,
+      toolName,
       reason: "execShell requires NOLO_LOCAL_SHELL_MODE=worktree.",
     };
   }
 
-  if (NEVER_LOCAL_TOOLS.has(args.toolName)) {
+  if (NEVER_LOCAL_TOOLS.has(toolName)) {
     return {
       allowed: false,
-      toolName: args.toolName,
-      reason: `${args.toolName} is blocked by the local runtime safety policy.`,
+      toolName,
+      reason: `${toolName} is blocked by the local runtime safety policy.`,
     };
   }
 
-  if (REMOVED_LOCAL_TOOLS.has(args.toolName)) {
+  if (REMOVED_LOCAL_TOOLS.has(toolName)) {
     return {
       allowed: false,
-      toolName: args.toolName,
-      reason: `${args.toolName} has been removed from the local runtime tool surface. Use execShell in shell-enabled workspace runs when shell is needed.`,
+      toolName,
+      reason: `${toolName} has been removed from the local runtime tool surface. Use execShell in shell-enabled workspace runs when shell is needed.`,
     };
   }
 
   const allowedByEnv = new Set(parseToolAllowlist(args.env.NOLO_LOCAL_ALLOWED_TOOLS));
-  const agentTools = new Set(args.agentToolNames ?? []);
-  if (!restrictedMode && agentTools.has(args.toolName)) {
-    return { allowed: true, toolName: args.toolName };
+  const agentTools = new Set(
+    (args.agentToolNames ?? []).map(normalizeLocalToolName).filter(Boolean),
+  );
+  if (!restrictedMode && agentTools.has(toolName)) {
+    return { allowed: true, toolName };
   }
-  if (DEFAULT_LOCAL_TOOLS.has(args.toolName) && agentTools.has(args.toolName)) {
-    return { allowed: true, toolName: args.toolName };
+  if (DEFAULT_LOCAL_TOOLS.has(toolName) && agentTools.has(toolName)) {
+    return { allowed: true, toolName };
   }
-  if (allowedByEnv.has(args.toolName) && agentTools.has(args.toolName)) {
-    return { allowed: true, toolName: args.toolName };
+  if (allowedByEnv.has(toolName) && agentTools.has(toolName)) {
+    return { allowed: true, toolName };
   }
 
   return {
     allowed: false,
-    toolName: args.toolName,
+    toolName,
     reason:
-      `${args.toolName} is not enabled for local runtime runs. ` +
+      `${toolName} is not enabled for local runtime runs. ` +
       "Set NOLO_LOCAL_ALLOWED_TOOLS and make sure the agent declares the tool before using it locally.",
   };
 }
@@ -134,9 +163,29 @@ export async function executeLocalToolWithPolicy(args: {
   });
   if (!decision.allowed) throw new Error(decision.reason);
 
-  const executor = args.executors?.[args.call.name];
+  const executor = args.executors?.[decision.toolName];
   if (!executor) {
-    throw new Error(`${args.call.name} is allowed by policy but no local executor is registered.`);
+    throw new Error(`${decision.toolName} is allowed by policy but no local executor is registered.`);
   }
-  return executor(args.call);
+  if (decision.toolName === "execShell") {
+    const parsed = parseShellCommandPayload(args.call.arguments);
+    const shellPolicy = evaluateShellCommandPolicy({
+      command: parsed.command ?? parsed.cmd,
+      input: parsed.input,
+      userInput: args.call.userInput,
+    });
+    if (shellPolicy.verdict === "forbidden") {
+      const error = new Error(shellPolicy.reason) as Error & {
+        code?: string;
+        policy?: Record<string, unknown>;
+      };
+      error.code = shellPolicy.code;
+      error.policy = shellPolicy.policy;
+      throw error;
+    }
+  }
+  return executor({
+    ...args.call,
+    name: decision.toolName,
+  });
 }

package/agent-runtime/openAiCompatibleProvider.ts

@@ -2,11 +2,13 @@ import type {
   AgentRuntimeChatMessage,
   AgentRuntimeResult,
 } from "./types";
+import { buildProviderAuthHeaders } from "./providerResolution";
 
 export type OpenAiCompatibleProviderConfig = {
   model: string;
   endpoint: string;
   apiKey: string;
+  apiKeyHeader?: string;
   provider: string;
   requestOptions: Record<string, number | string>;
 };
@@ -41,9 +43,11 @@ export function buildOpenAiCompatibleChatCompletionRequest(args: {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        ...(args.providerConfig.apiKey
-          ? { Authorization: `Bearer ${args.providerConfig.apiKey}` }
-          : {}),
+        ...buildProviderAuthHeaders({
+          endpoint: args.providerConfig.endpoint,
+          apiKey: args.providerConfig.apiKey,
+          apiKeyHeader: args.providerConfig.apiKeyHeader,
+        }),
       },
       body: JSON.stringify(body),
     },

package/agent-runtime/openAiCompatibleProviderConfig.ts

@@ -1,38 +1,27 @@
 import type { AgentRuntimeAgentConfig } from "./hostAdapter";
 import type { OpenAiCompatibleProviderConfig } from "./openAiCompatibleProvider";
-import { pickAgentRuntimeInferenceOptions } from "./agentConfigOptions";
+import { buildProviderExecutionPlan } from "./providerResolution";
 
 type EnvLike = Record<string, string | undefined>;
 
-function trimTrailingSlash(value: string) {
-  return value.replace(/\/+$/, "");
-}
-
-function resolveChatCompletionsEndpoint(value: string) {
-  const trimmed = trimTrailingSlash(value.trim());
-  return trimmed.endsWith("/chat/completions")
-    ? trimmed
-    : `${trimmed}/chat/completions`;
-}
-
-function resolveOpenAiCompatibleBaseUrl(env: EnvLike) {
-  return env.NOLO_LOCAL_OPENAI_BASE_URL || env.OPENAI_BASE_URL || "https://api.openai.com/v1";
-}
-
-function resolveOpenAiCompatibleApiKey(env: EnvLike) {
-  return env.OPENAI_API_KEY || env.NOLO_LOCAL_OPENAI_API_KEY || "";
-}
-
 export function resolveOpenAiCompatibleProviderConfig(args: {
   agentConfig: AgentRuntimeAgentConfig;
   env: EnvLike;
 }): OpenAiCompatibleProviderConfig {
-  const customProviderUrl = args.agentConfig.customProviderUrl?.trim();
+  const plan = buildProviderExecutionPlan({
+    agentConfig: args.agentConfig,
+    env: args.env,
+    runtimeKind: "local",
+  });
+  if (plan.mode === "cli" || plan.transport !== "direct") {
+    throw new Error("OpenAI-compatible provider config requires a direct provider execution plan.");
+  }
   return {
-    model: args.agentConfig.model || "gpt-4.1-mini",
-    endpoint: resolveChatCompletionsEndpoint(customProviderUrl || resolveOpenAiCompatibleBaseUrl(args.env)),
-    apiKey: resolveOpenAiCompatibleApiKey(args.env),
-    provider: args.agentConfig.provider || "openai-compatible",
-    requestOptions: pickAgentRuntimeInferenceOptions(args.agentConfig),
+    model: plan.model,
+    endpoint: plan.endpoint,
+    apiKey: plan.apiKey,
+    ...(plan.apiKeyHeader ? { apiKeyHeader: plan.apiKeyHeader } : {}),
+    provider: plan.provider,
+    requestOptions: plan.requestOptions,
   };
 }

package/agent-runtime/platformChatProvider.ts

@@ -3,23 +3,19 @@ import type {
   AgentRuntimeChatMessage,
   AgentRuntimeResult,
 } from "./types";
-import { pickAgentRuntimeInferenceOptions } from "./agentConfigOptions";
+import {
+  buildProviderExecutionPlan,
+  canUsePlatformChatProvider as canUsePlatformChatProviderFromEnv,
+  hasDirectOpenAiCompatibleProvider as hasDirectOpenAiCompatibleProviderFromEnv,
+  resolvePlatformAuthToken,
+  resolvePlatformServerUrl,
+  shouldUsePlatformProxyTransport,
+} from "./providerResolution";
 
 type EnvLike = Record<string, string | undefined>;
 
 const CHAT_PROXY_PATH = "/api/v1/chat";
 
-const PROVIDER_ENDPOINTS: Record<string, string> = {
-  deepinfra: "https://api.deepinfra.com/v1/openai/chat/completions",
-  deepseek: "https://api.deepseek.com/chat/completions",
-  fireworks: "https://api.fireworks.ai/inference/v1/chat/completions",
-  google: "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
-  mistral: "https://api.mistral.ai/v1/chat/completions",
-  mimo: "https://token-plan-cn.xiaomimimo.com/v1/chat/completions",
-  openai: "https://api.openai.com/v1/chat/completions",
-  openrouter: "https://openrouter.ai/api/v1/chat/completions",
-};
-
 export type PlatformChatProviderConfig = {
   serverUrl: string;
   authToken: string;
@@ -29,46 +25,12 @@ export type PlatformChatProviderConfig = {
   endpoint: string;
   requestOptions: Record<string, number | string>;
   apiKey?: string;
+  apiKeyHeader?: string;
   apiSource?: string;
 };
 
 type PlatformChatTool = Record<string, unknown>;
 
-function trimTrailingSlash(value: string) {
-  return value.trim().replace(/\/+$/, "");
-}
-
-function resolveChatCompletionsEndpoint(value: string) {
-  const trimmed = trimTrailingSlash(value);
-  return trimmed.endsWith("/chat/completions")
-    ? trimmed
-    : `${trimmed}/chat/completions`;
-}
-
-function resolvePlatformServerUrl(env: EnvLike) {
-  return trimTrailingSlash(env.NOLO_SERVER || env.BASE_URL || "https://nolo.chat");
-}
-
-function resolvePlatformAuthToken(env: EnvLike) {
-  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
-}
-
-function resolveProviderEndpoint(agentConfig: AgentRuntimeAgentConfig) {
-  const customProviderUrl = agentConfig.customProviderUrl?.trim();
-  if (customProviderUrl) return resolveChatCompletionsEndpoint(customProviderUrl);
-
-  const provider = agentConfig.provider?.trim().toLowerCase();
-  if (!provider) {
-    throw new Error("Platform chat provider requires agentConfig.provider.");
-  }
-
-  const endpoint = PROVIDER_ENDPOINTS[provider];
-  if (!endpoint) {
-    throw new Error(`Platform chat provider does not support provider "${provider}".`);
-  }
-  return endpoint;
-}
-
 function shouldDisableThinking(providerConfig: PlatformChatProviderConfig) {
   return (
     providerConfig.provider.toLowerCase() === "mimo" ||
@@ -90,19 +52,39 @@ export function resolvePlatformChatProviderConfig(args: {
   agentConfig: AgentRuntimeAgentConfig;
   env: EnvLike;
 }): PlatformChatProviderConfig {
-  const provider = args.agentConfig.provider || args.agentConfig.apiSource || "openai";
+  const plan = buildProviderExecutionPlan({
+    agentConfig: args.agentConfig,
+    env: args.env,
+    runtimeKind: "local",
+  });
+  if (plan.mode === "cli") {
+    throw new Error("Platform chat provider does not support cli agents.");
+  }
+  if (plan.transport === "direct") {
+    return {
+      serverUrl: resolvePlatformServerUrl(args.env),
+      authToken: resolvePlatformAuthToken(args.env),
+      agentKey: args.agentConfig.key,
+      model: plan.model,
+      provider: plan.provider,
+      endpoint: plan.endpoint,
+      requestOptions: plan.requestOptions,
+      ...(plan.apiKey ? { apiKey: plan.apiKey } : {}),
+      ...(plan.apiKeyHeader ? { apiKeyHeader: plan.apiKeyHeader } : {}),
+      ...(args.agentConfig.apiSource ? { apiSource: args.agentConfig.apiSource } : {}),
+    };
+  }
   return {
-    serverUrl: resolvePlatformServerUrl(args.env),
-    authToken: resolvePlatformAuthToken(args.env),
-    agentKey: args.agentConfig.key,
-    model: args.agentConfig.model || "gpt-4.1-mini",
-    provider,
-    endpoint: resolveProviderEndpoint(args.agentConfig),
-    requestOptions: pickAgentRuntimeInferenceOptions(args.agentConfig),
-    ...(typeof args.agentConfig.rawRecord?.apiKey === "string"
-      ? { apiKey: args.agentConfig.rawRecord.apiKey.trim() }
-      : {}),
-    ...(args.agentConfig.apiSource ? { apiSource: args.agentConfig.apiSource } : {}),
+    serverUrl: plan.serverUrl,
+    authToken: plan.authToken,
+    agentKey: plan.agentKey,
+    model: plan.model,
+    provider: plan.provider,
+    endpoint: plan.endpoint,
+    requestOptions: plan.requestOptions,
+    ...(plan.apiKey ? { apiKey: plan.apiKey } : {}),
+    ...(plan.apiKeyHeader ? { apiKeyHeader: plan.apiKeyHeader } : {}),
+    ...(plan.apiSource ? { apiSource: plan.apiSource } : {}),
   };
 }
 
@@ -123,6 +105,7 @@ export function buildPlatformChatCompletionRequest(args: {
     agentKey: args.providerConfig.agentKey,
     ...(args.providerConfig.apiSource ? { apiSource: args.providerConfig.apiSource } : {}),
     ...(args.providerConfig.apiKey ? { KEY: args.providerConfig.apiKey } : {}),
+    ...(args.providerConfig.apiKeyHeader ? { apiKeyHeader: args.providerConfig.apiKeyHeader } : {}),
   };
 
   return {
@@ -216,21 +199,17 @@ export function parsePlatformChatCompletionResponse(args: {
 }
 
 export function canUsePlatformChatProvider(env: EnvLike) {
-  return Boolean(resolvePlatformAuthToken(env));
+  return canUsePlatformChatProviderFromEnv(env);
 }
 
 export function hasDirectOpenAiCompatibleProvider(env: EnvLike) {
-  return Boolean(
-    env.NOLO_LOCAL_OPENAI_API_KEY ||
-      env.OPENAI_API_KEY ||
-      env.NOLO_LOCAL_OPENAI_BASE_URL ||
-      env.OPENAI_BASE_URL ||
-      env.OLLAMA_BASE_URL
-  );
+  return hasDirectOpenAiCompatibleProviderFromEnv(env);
 }
 
 function agentRequiresPlatformChatProvider(agentConfig?: AgentRuntimeAgentConfig) {
-  return agentConfig?.apiSource === "platform" || agentConfig?.rawRecord?.useServerProxy === true;
+  if (agentConfig?.apiSource === "platform") return true;
+  if (agentConfig?.apiSource === "custom" || agentConfig?.customProviderUrl?.trim()) return false;
+  return agentConfig?.useServerProxy === true;
 }
 
 export function shouldUsePlatformChatProvider(
@@ -238,7 +217,5 @@ export function shouldUsePlatformChatProvider(
   agentConfig?: AgentRuntimeAgentConfig
 ) {
   if (agentRequiresPlatformChatProvider(agentConfig)) return true;
-  if (env.NOLO_LOCAL_LLM === "platform") return true;
-  if (env.NOLO_LOCAL_LLM === "direct") return false;
-  return !hasDirectOpenAiCompatibleProvider(env) && canUsePlatformChatProvider(env);
+  return shouldUsePlatformProxyTransport(env, agentConfig);
 }