nolo-cli 0.1.45 → 0.1.46

package/agent-runtime/platformChatProvider.ts

@@ -1,229 +0,0 @@
-import type { AgentRuntimeAgentConfig } from "./hostAdapter";
-import type {
-  AgentRuntimeChatMessage,
-  AgentRuntimeResult,
-} from "./types";
-import {
-  buildProviderExecutionPlan,
-  canUsePlatformChatProvider as canUsePlatformChatProviderFromEnv,
-  hasDirectOpenAiCompatibleProvider as hasDirectOpenAiCompatibleProviderFromEnv,
-  resolveAgentRuntimeLocation,
-  resolvePlatformAuthToken,
-  resolvePlatformServerUrl,
-  resolveProviderTransportDecision,
-} from "./providerResolution";
-
-type EnvLike = Record<string, string | undefined>;
-
-const CHAT_PROXY_PATH = "/api/v1/chat";
-
-export type PlatformChatProviderConfig = {
-  serverUrl: string;
-  authToken: string;
-  agentKey: string;
-  model: string;
-  provider: string;
-  endpoint: string;
-  requestOptions: Record<string, number | string>;
-  apiKey?: string;
-  apiKeyHeader?: string;
-  apiSource?: string;
-};
-
-type PlatformChatTool = Record<string, unknown>;
-
-function shouldDisableThinking(providerConfig: PlatformChatProviderConfig) {
-  return (
-    providerConfig.provider.toLowerCase() === "mimo" ||
-    /xiaomimimo\.com/i.test(providerConfig.endpoint)
-  );
-}
-
-function toOpenAiCompatibleMessages(messages: AgentRuntimeChatMessage[]) {
-  return messages.map((message) => ({
-    role: message.role,
-    content: message.content ?? "",
-    ...(message.tool_call_id ? { tool_call_id: message.tool_call_id } : {}),
-    ...(Array.isArray(message.tool_calls) ? { tool_calls: message.tool_calls } : {}),
-    ...(message.reasoning_content ? { reasoning_content: message.reasoning_content } : {}),
-  }));
-}
-
-export function resolvePlatformChatProviderConfig(args: {
-  agentConfig: AgentRuntimeAgentConfig;
-  env: EnvLike;
-}): PlatformChatProviderConfig {
-  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: 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 } : {}),
-  };
-}
-
-export function buildPlatformChatCompletionRequest(args: {
-  providerConfig: PlatformChatProviderConfig;
-  messages: AgentRuntimeChatMessage[];
-  tools?: PlatformChatTool[];
-}) {
-  const body = {
-    model: args.providerConfig.model,
-    messages: toOpenAiCompatibleMessages(args.messages),
-    stream: false,
-    ...args.providerConfig.requestOptions,
-    ...(args.tools && args.tools.length > 0 ? { tools: args.tools, tool_choice: "auto" } : {}),
-    ...(shouldDisableThinking(args.providerConfig) ? { thinking: { type: "disabled" } } : {}),
-    url: args.providerConfig.endpoint,
-    provider: args.providerConfig.provider,
-    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 {
-    url: `${args.providerConfig.serverUrl}${CHAT_PROXY_PATH}`,
-    init: {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${args.providerConfig.authToken}`,
-      },
-      body: JSON.stringify(body),
-    },
-  };
-}
-
-function tryParseJson(raw: string) {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-
-function extractJsonObjects(raw: string) {
-  const objects: any[] = [];
-  let depth = 0;
-  let start = -1;
-  let inString = false;
-  let escaped = false;
-
-  for (let index = 0; index < raw.length; index += 1) {
-    const char = raw[index];
-    if (inString) {
-      if (escaped) {
-        escaped = false;
-      } else if (char === "\\") {
-        escaped = true;
-      } else if (char === "\"") {
-        inString = false;
-      }
-      continue;
-    }
-
-    if (char === "\"") {
-      inString = true;
-      continue;
-    }
-    if (char === "{") {
-      if (depth === 0) start = index;
-      depth += 1;
-      continue;
-    }
-    if (char !== "}" || depth === 0) continue;
-
-    depth -= 1;
-    if (depth === 0 && start >= 0) {
-      const parsed = tryParseJson(raw.slice(start, index + 1));
-      if (parsed) objects.push(parsed);
-      start = -1;
-    }
-  }
-
-  return objects;
-}
-
-export function parsePlatformChatCompletionData(raw: string) {
-  const direct = tryParseJson(raw.trim());
-  if (direct) return direct;
-
-  const objects = extractJsonObjects(raw);
-  return objects.find((object) => Array.isArray(object?.choices)) ?? objects[0] ?? {};
-}
-
-export function parsePlatformChatCompletionResponse(args: {
-  providerConfig: PlatformChatProviderConfig;
-  data: any;
-  trace: AgentRuntimeChatMessage[];
-}): AgentRuntimeResult {
-  const choiceMessage = args.data?.choices?.[0]?.message ?? {};
-  return {
-    content: String(choiceMessage?.content ?? ""),
-    model: args.providerConfig.model,
-    provider: args.providerConfig.provider,
-    ...(Array.isArray(choiceMessage?.tool_calls) ? { tool_calls: choiceMessage.tool_calls } : {}),
-    ...(typeof choiceMessage?.reasoning_content === "string" && choiceMessage.reasoning_content
-      ? { reasoning_content: choiceMessage.reasoning_content }
-      : {}),
-    usage: args.data?.usage,
-    trace: args.trace,
-  };
-}
-
-export function canUsePlatformChatProvider(env: EnvLike) {
-  return canUsePlatformChatProviderFromEnv(env);
-}
-
-export function hasDirectOpenAiCompatibleProvider(env: EnvLike) {
-  return hasDirectOpenAiCompatibleProviderFromEnv(env);
-}
-
-export function shouldUsePlatformChatProvider(
-  env: EnvLike,
-  agentConfig?: AgentRuntimeAgentConfig
-) {
-  if (!agentConfig) {
-    return resolveProviderTransportDecision({
-      agentConfig: { key: "default-platform" },
-      env,
-      runtimeLocation: "local-host",
-    }).transport === "proxy";
-  }
-  return resolveProviderTransportDecision({
-    agentConfig,
-    env,
-    runtimeLocation: resolveAgentRuntimeLocation({
-      agentConfig,
-      runtimeKind: "local",
-    }),
-  }).transport === "proxy";
-}

package/agent-runtime/providerResolution.ts

@@ -1,302 +0,0 @@
-import type { AgentRuntimeAgentConfig } from "./hostAdapter";
-import { pickAgentRuntimeInferenceOptions } from "./agentConfigOptions";
-
-type EnvLike = Record<string, string | undefined>;
-
-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 AgentProviderMode = "cli" | "platform" | "custom";
-export type ProviderExecutionTransport = "direct" | "proxy";
-export type AgentRuntimeLocation = "server" | "bound-machine" | "local-host";
-
-export type ProviderTransportDecision = {
-  mode: AgentProviderMode;
-  transport: ProviderExecutionTransport;
-  reason:
-    | "cli-provider"
-    | "custom-provider"
-    | "custom-server-proxy"
-    | "platform-agent"
-    | "forced-platform-env"
-    | "forced-direct-env"
-    | "direct-provider-env"
-    | "platform-proxy-fallback";
-};
-
-type ProviderExecutionPlanBase = {
-  mode: AgentProviderMode;
-  transport: ProviderExecutionTransport;
-  model: string;
-  provider: string;
-  requestOptions: Record<string, number | string>;
-};
-
-export type CliProviderExecutionPlan = ProviderExecutionPlanBase & {
-  mode: "cli";
-  transport: "direct";
-  cliProvider: string;
-};
-
-export type DirectProviderExecutionPlan = ProviderExecutionPlanBase & {
-  mode: "platform" | "custom";
-  transport: "direct";
-  endpoint: string;
-  apiKey: string;
-  apiKeyHeader?: string;
-};
-
-export type ProxyProviderExecutionPlan = ProviderExecutionPlanBase & {
-  mode: "platform" | "custom";
-  transport: "proxy";
-  endpoint: string;
-  serverUrl: string;
-  authToken: string;
-  agentKey: string;
-  apiSource?: string;
-  apiKey?: string;
-  apiKeyHeader?: string;
-};
-
-export type ProviderExecutionPlan =
-  | CliProviderExecutionPlan
-  | DirectProviderExecutionPlan
-  | ProxyProviderExecutionPlan;
-
-export function trimTrailingSlash(value: string) {
-  return value.trim().replace(/\/+$/, "");
-}
-
-export function resolveChatCompletionsEndpoint(value: string) {
-  const trimmed = trimTrailingSlash(value);
-  return trimmed.endsWith("/chat/completions")
-    ? trimmed
-    : `${trimmed}/chat/completions`;
-}
-
-export function resolveOpenAiCompatibleBaseUrl(env: EnvLike) {
-  return env.NOLO_LOCAL_OPENAI_BASE_URL || env.OPENAI_BASE_URL || "https://api.openai.com/v1";
-}
-
-export function resolveOpenAiCompatibleApiKey(env: EnvLike) {
-  return env.OPENAI_API_KEY || env.NOLO_LOCAL_OPENAI_API_KEY || "";
-}
-
-export function resolvePlatformServerUrl(env: EnvLike) {
-  return trimTrailingSlash(env.NOLO_SERVER || env.BASE_URL || "https://nolo.chat");
-}
-
-export function resolvePlatformAuthToken(env: EnvLike) {
-  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
-}
-
-export function canUsePlatformChatProvider(env: EnvLike) {
-  return Boolean(resolvePlatformAuthToken(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
-  );
-}
-
-function resolvePlatformProviderEndpoint(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;
-}
-
-export function resolveAgentProviderMode(agentConfig: AgentRuntimeAgentConfig): AgentProviderMode {
-  if (agentConfig.apiSource === "cli" || agentConfig.provider === "cli" || agentConfig.cliProvider) {
-    return "cli";
-  }
-  if (agentConfig.apiSource === "custom" || agentConfig.customProviderUrl) {
-    return "custom";
-  }
-  return "platform";
-}
-
-export function resolveAgentRuntimeLocation(args: {
-  agentConfig: AgentRuntimeAgentConfig;
-  runtimeKind: "local" | "desktop" | "server";
-}): AgentRuntimeLocation {
-  const runtimeBinding = args.agentConfig.runtimeBinding;
-  const machineId = typeof runtimeBinding?.machineId === "string"
-    ? runtimeBinding.machineId.trim()
-    : "";
-  if (machineId) return "bound-machine";
-  if (args.runtimeKind === "server") return "server";
-  return "local-host";
-}
-
-export function resolveProviderTransportDecision(args: {
-  agentConfig: AgentRuntimeAgentConfig;
-  env: EnvLike;
-  runtimeLocation: AgentRuntimeLocation;
-}): ProviderTransportDecision {
-  const mode = resolveAgentProviderMode(args.agentConfig);
-  if (mode === "cli") {
-    return { mode, transport: "direct", reason: "cli-provider" };
-  }
-  if (mode === "custom") {
-    if (args.runtimeLocation === "server" && args.agentConfig.useServerProxy === true) {
-      return { mode, transport: "proxy", reason: "custom-server-proxy" };
-    }
-    return { mode, transport: "direct", reason: "custom-provider" };
-  }
-  if (args.agentConfig.apiSource === "platform" || args.agentConfig.useServerProxy === true) {
-    return { mode, transport: "proxy", reason: "platform-agent" };
-  }
-  if (args.env.NOLO_LOCAL_LLM === "platform") {
-    return { mode, transport: "proxy", reason: "forced-platform-env" };
-  }
-  if (args.env.NOLO_LOCAL_LLM === "direct") {
-    return { mode, transport: "direct", reason: "forced-direct-env" };
-  }
-  if (hasDirectOpenAiCompatibleProvider(args.env)) {
-    return { mode, transport: "direct", reason: "direct-provider-env" };
-  }
-  if (canUsePlatformChatProvider(args.env)) {
-    return { mode, transport: "proxy", reason: "platform-proxy-fallback" };
-  }
-  return { mode, transport: "direct", reason: "direct-provider-env" };
-}
-
-export function resolveProviderAuthHeaderName(args: {
-  endpoint: string;
-  apiKeyHeader?: string;
-}) {
-  const explicitHeader = args.apiKeyHeader?.trim();
-  if (explicitHeader) return explicitHeader;
-  if (/xiaomimimo\.com/i.test(args.endpoint)) return "api-key";
-  return "Authorization";
-}
-
-export function buildProviderAuthHeaders(args: {
-  endpoint: string;
-  apiKey: string;
-  apiKeyHeader?: string;
-}) {
-  if (!args.apiKey) return {};
-  const headerName = resolveProviderAuthHeaderName(args);
-  return headerName.toLowerCase() === "authorization"
-    ? { Authorization: `Bearer ${args.apiKey}` }
-    : { [headerName]: args.apiKey };
-}
-
-export function buildProviderExecutionPlan(args: {
-  agentConfig: AgentRuntimeAgentConfig;
-  env: EnvLike;
-  runtimeKind: "local" | "desktop" | "server";
-}): ProviderExecutionPlan {
-  const { agentConfig, env } = args;
-  const mode = resolveAgentProviderMode(agentConfig);
-  const runtimeLocation = resolveAgentRuntimeLocation({
-    agentConfig,
-    runtimeKind: args.runtimeKind,
-  });
-  const transportDecision = resolveProviderTransportDecision({
-    agentConfig,
-    env,
-    runtimeLocation,
-  });
-  const model = agentConfig.model || "gpt-4.1-mini";
-  const requestOptions = pickAgentRuntimeInferenceOptions(agentConfig);
-
-  if (mode === "cli") {
-    return {
-      mode,
-      transport: "direct",
-      cliProvider: agentConfig.cliProvider || agentConfig.provider || "codex",
-      model,
-      provider: agentConfig.provider || "cli",
-      requestOptions,
-    };
-  }
-
-  if (mode === "custom") {
-    const endpoint = resolveChatCompletionsEndpoint(agentConfig.customProviderUrl || resolveOpenAiCompatibleBaseUrl(env));
-    const apiKey = agentConfig.apiKey?.trim() || agentConfig.apiKeyFromAgentKey?.trim() || "";
-    const apiKeyHeader = resolveProviderAuthHeaderName({
-      endpoint,
-      apiKeyHeader: agentConfig.apiKeyHeader,
-    });
-    if (transportDecision.transport === "proxy") {
-      return {
-        mode,
-        transport: "proxy",
-        model,
-        provider: agentConfig.provider || "custom",
-        endpoint,
-        requestOptions,
-        serverUrl: resolvePlatformServerUrl(env),
-        authToken: resolvePlatformAuthToken(env),
-        agentKey: agentConfig.key,
-        ...(agentConfig.apiSource ? { apiSource: agentConfig.apiSource } : {}),
-        ...(apiKey ? { apiKey } : {}),
-        ...(apiKeyHeader ? { apiKeyHeader } : {}),
-      };
-    }
-    return {
-      mode,
-      transport: "direct",
-      model,
-      provider: agentConfig.provider || "custom",
-      endpoint,
-      requestOptions,
-      apiKey,
-      ...(apiKeyHeader ? { apiKeyHeader } : {}),
-    };
-  }
-
-  const provider = agentConfig.provider || agentConfig.apiSource || "openai";
-  const endpoint = transportDecision.transport === "proxy"
-    ? resolvePlatformProviderEndpoint(agentConfig)
-    : resolveChatCompletionsEndpoint(resolveOpenAiCompatibleBaseUrl(env));
-  if (transportDecision.transport === "proxy") {
-    return {
-      mode,
-      transport: "proxy",
-      model,
-      provider,
-      endpoint,
-      requestOptions,
-      serverUrl: resolvePlatformServerUrl(env),
-      authToken: resolvePlatformAuthToken(env),
-      agentKey: agentConfig.key,
-      ...(agentConfig.apiSource ? { apiSource: agentConfig.apiSource } : {}),
-      ...(agentConfig.apiKey?.trim() ? { apiKey: agentConfig.apiKey.trim() } : {}),
-      ...(agentConfig.apiKeyHeader?.trim() ? { apiKeyHeader: agentConfig.apiKeyHeader.trim() } : {}),
-    };
-  }
-  return {
-    mode,
-    transport: "direct",
-    model,
-    provider: agentConfig.provider || "openai-compatible",
-    endpoint,
-    requestOptions,
-    apiKey: resolveOpenAiCompatibleApiKey(env),
-  };
-}

package/agent-runtime/runtimeDecision.ts

@@ -1,70 +0,0 @@
-import type {
-  AgentRuntimeDecision,
-  AgentRuntimeDecisionInput,
-} from "./types";
-
-function uniqueCapabilities(capabilities: string[]) {
-  return [...new Set(capabilities.filter(Boolean))];
-}
-
-function localMissingCapabilities(input: AgentRuntimeDecisionInput) {
-  const missing = [...(input.missingLocalCapabilities ?? [])];
-  if (!input.hasLocalAgentConfig) missing.push("agent-config");
-  if (!input.hasLocalProvider) missing.push("provider");
-  if (!input.hasLocalPersistence) missing.push("persistence");
-  if (input.requiresServer) missing.push("server-required");
-  if (input.host === "web") missing.push("local-host-adapter");
-  return uniqueCapabilities(missing);
-}
-
-export function resolveAgentRuntimeDecision(
-  input: AgentRuntimeDecisionInput
-): AgentRuntimeDecision {
-  const requestedMode = input.requestedMode ?? "auto";
-  const missingLocalCapabilities = localMissingCapabilities(input);
-  const localRunnable = missingLocalCapabilities.length === 0;
-
-  if (requestedMode === "server") {
-    return {
-      mode: "server",
-      runnable: input.serverFallbackAvailable,
-      reason: input.serverFallbackAvailable
-        ? "server runtime was requested"
-        : "server runtime was requested but no server fallback is available",
-      missingLocalCapabilities,
-      syncAfterRun: false,
-    };
-  }
-
-  if (requestedMode === "local") {
-    return {
-      mode: "local",
-      runnable: localRunnable,
-      reason: localRunnable
-        ? "local runtime was requested and all local capabilities are available"
-        : "local runtime was requested but local capabilities are missing",
-      missingLocalCapabilities,
-      syncAfterRun: localRunnable && Boolean(input.syncRequested),
-    };
-  }
-
-  if (localRunnable) {
-    return {
-      mode: "local",
-      runnable: true,
-      reason: "local runtime capabilities are available",
-      missingLocalCapabilities,
-      syncAfterRun: Boolean(input.syncRequested),
-    };
-  }
-
-  return {
-    mode: "server",
-    runnable: input.serverFallbackAvailable,
-    reason: input.serverFallbackAvailable
-      ? "local runtime capabilities are missing; using server fallback"
-      : "local runtime capabilities are missing and no server fallback is available",
-    missingLocalCapabilities,
-    syncAfterRun: false,
-  };
-}

package/agent-runtime/runtimeFacts.ts

@@ -1,40 +0,0 @@
-import type {
-  AgentRuntimeDecisionInput,
-  AgentRuntimeHost,
-  AgentRuntimeRequestedMode,
-} from "./types";
-
-export type AgentRuntimeCapabilityFacts = {
-  host: AgentRuntimeHost;
-  requestedMode?: AgentRuntimeRequestedMode;
-  syncRequested?: boolean;
-  capabilities: string[];
-  requiresServer?: boolean;
-  serverFallbackAvailable: boolean;
-};
-
-export function buildAgentRuntimeDecisionInput(
-  facts: AgentRuntimeCapabilityFacts
-): AgentRuntimeDecisionInput {
-  const capabilities = new Set(facts.capabilities);
-  const hasLocalAgentConfig = capabilities.has("leveldb-agent-config") || capabilities.has("agent-config");
-  const hasLocalProvider = capabilities.has("local-provider") || capabilities.has("provider");
-  const hasLocalPersistence = capabilities.has("leveldb-persistence") || capabilities.has("persistence");
-  const missingLocalCapabilities = [
-    ...(hasLocalAgentConfig ? [] : ["agent-config"]),
-    ...(hasLocalProvider ? [] : ["provider"]),
-    ...(hasLocalPersistence ? [] : ["persistence"]),
-  ];
-
-  return {
-    host: facts.host,
-    ...(facts.requestedMode ? { requestedMode: facts.requestedMode } : {}),
-    syncRequested: Boolean(facts.syncRequested),
-    hasLocalAgentConfig,
-    hasLocalProvider,
-    hasLocalPersistence,
-    missingLocalCapabilities,
-    requiresServer: Boolean(facts.requiresServer),
-    serverFallbackAvailable: facts.serverFallbackAvailable,
-  };
-}