Add deployment provider credential routing

README.md

@@ -137,7 +137,7 @@ Inside a project's Studio, the same design system streams out multiple artifact
   <img src="https://repo-assets.open-design.ai/resources/images/coding-agents.png" alt="The 25 coding-agent CLIs Open Design supports — Claude Code · Codex · OpenCode · Hermes · Antigravity · Vela · Grok Build · Kimi · Cursor Agent · Qwen · Qoder · GitHub Copilot · Pi · Kiro · Kilo · Mistral Vibe · DeepSeek · Reasonix · Aider · Amp · CodeBuddy · Mimo · AtomCode · Devin · Trae" width="100%" />
 </p>
 
-**No CLI installed?** The BYOK proxy at `POST /api/proxy/{anthropic,openai,azure,google,ollama,senseaudio}/stream` gives you the same loop (no process spawn) — paste `baseUrl` + `apiKey` + `model`, with presets for OpenAI, Atlas Cloud, Anthropic, Azure OpenAI, Google Gemini, Ollama, LM Studio, vLLM, or any OpenAI-compatible endpoint. Atlas Cloud uses `https://api.atlascloud.ai/v1` with your own key and OpenAI-compatible model ids such as `qwen/qwen3.5-flash`. Per-target SSRF protection blocks internal IPs / link-local / CGNAT at the daemon edge.
+**No CLI installed?** The BYOK proxy at `POST /api/proxy/{anthropic,openai,azure,google,ollama,senseaudio}/stream` gives you the same loop (no process spawn) — paste `baseUrl` + `apiKey` + `model`, with presets for OpenAI, Atlas Cloud, Anthropic, Azure OpenAI, Google Gemini, Ollama, LM Studio, vLLM, or any OpenAI-compatible endpoint. Atlas Cloud uses `https://api.atlascloud.ai/v1` with your own key and OpenAI-compatible model ids such as `qwen/qwen3.5-flash`. Per-target SSRF protection blocks internal IPs / link-local / CGNAT at the daemon edge. Self-host administrators can also preconfigure an OpenAI-compatible provider orchestrator for deployment-owned credentials; see [`deploy/README.md`](deploy/README.md#deployment-provider-gateway).
 
 Runtime definitions live in [`apps/daemon/src/runtimes/defs/`](apps/daemon/src/runtimes/defs/), with registration and shared stream handling under [`apps/daemon/src/runtimes/`](apps/daemon/src/runtimes/). See [`docs/agent-adapters.md`](docs/agent-adapters.md) for the adapter contract.
 

apps/daemon/src/api-token-auth.ts

@@ -14,3 +14,25 @@ export function apiTokenFromEnv(env: NodeJS.ProcessEnv = process.env): string {
 export function isApiTokenMiddlewareEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
   return apiTokenFromEnv(env).length > 0 && !isApiAuthDisabled(env);
 }
+
+const apiTokenOpenProbePaths = new Set([
+  '/health',
+  '/api/health',
+  '/ready',
+  '/api/ready',
+  '/version',
+  '/api/version',
+]);
+
+const apiTokenOpenGetPaths = new Set([
+  // Redacted admin-managed provider discovery. The route exposes availability
+  // and display metadata only; credentials remain daemon-side.
+  '/provider-orchestrator/config',
+  '/api/provider-orchestrator/config',
+]);
+
+export function isApiTokenExemptRequest(method: string, path: string): boolean {
+  if (apiTokenOpenProbePaths.has(path)) return true;
+  if (method.toUpperCase() === 'GET' && apiTokenOpenGetPaths.has(path)) return true;
+  return false;
+}

apps/daemon/src/cli.ts

@@ -121,6 +121,14 @@ const RESEARCH_SEARCH_BOOLEAN_FLAGS = new Set([
   'help',
   'h',
 ]);
+const PROVIDER_STRING_FLAGS = new Set([
+  'daemon-url',
+]);
+const PROVIDER_BOOLEAN_FLAGS = new Set([
+  'help',
+  'h',
+  'json',
+]);
 
 const PLUGIN_STRING_FLAGS = new Set([
   'daemon-url',
@@ -324,6 +332,7 @@ const PLUGIN_LIST_BOOLEAN_FLAGS = new Set([
 const SUBCOMMAND_MAP = {
   artifacts: runArtifacts,
   media: runMedia,
+  provider: runProvider,
   mcp: runMcp,
   amr: runAmr,
   research: runResearch,
@@ -641,6 +650,9 @@ function printRootHelp() {
   od research search --query <text> [--max-sources 5] [--daemon-url <url>]
       Run agent-callable Tavily research through the local daemon.
 
+  od provider config [--json] [--daemon-url <url>]
+      Inspect daemon-managed provider availability without printing credentials.
+
   od plugin <list|info|install|uninstall|apply|doctor|replay|trust> [args]
       Discover, install, and apply plugins through the local daemon.
   od plugin publish-repo <folder>
@@ -709,6 +721,73 @@ What the daemon does:
      dispatcher that the agent calls via \`od media generate\`.`);
 }
 
+// ---------------------------------------------------------------------------
+// Subcommand: od provider …
+// ---------------------------------------------------------------------------
+
+async function runProvider(args) {
+  const sub = args.find((a) => !a.startsWith('-')) || '';
+  if (!sub || sub === 'help' || args.includes('--help') || args.includes('-h')) {
+    printProviderHelp();
+    process.exit(sub === 'help' || args.includes('--help') || args.includes('-h') ? 0 : 2);
+  }
+  if (sub !== 'config') {
+    console.error(`unknown subcommand: od provider ${sub}`);
+    printProviderHelp();
+    process.exit(2);
+  }
+  const idx = args.indexOf(sub);
+  const rest = [...args.slice(0, idx), ...args.slice(idx + 1)];
+  let flags;
+  try {
+    flags = parseFlags(rest, {
+      string: PROVIDER_STRING_FLAGS,
+      boolean: PROVIDER_BOOLEAN_FLAGS,
+    });
+  } catch (err) {
+    console.error(err.message);
+    printProviderHelp();
+    process.exit(2);
+  }
+  const base = await cliDaemonBaseUrl(flags);
+  let resp;
+  try {
+    resp = await fetch(`${base}/api/provider-orchestrator/config`);
+  } catch (err) {
+    return exitWithStructuredError({
+      code: 'daemon-not-running',
+      message: `Cannot reach daemon at ${base}: ${err?.message ?? err}`,
+    });
+  }
+  if (!resp.ok) return structuredHttpFailure(resp);
+  const data = await resp.json();
+  if (flags.json) {
+    process.stdout.write(JSON.stringify(data, null, 2) + '\n');
+    return;
+  }
+  console.log(`[provider] ${data.available ? 'available' : 'unavailable'} (${data.kind ?? 'unknown'})`);
+  console.log(`  source:   ${data.credentialSource ?? 'deployment'}`);
+  console.log(`  protocol: ${data.protocol ?? 'openai'}`);
+  console.log(`  label:    ${data.label ?? 'Provider orchestrator'}`);
+  if (data.displayHost) console.log(`  host:     ${data.displayHost}`);
+  if (data.defaultModel) console.log(`  model:    ${data.defaultModel}`);
+  if (data.detail) console.log(`  detail:   ${data.detail}`);
+}
+
+function printProviderHelp() {
+  console.log(`Usage:
+  od provider config [--json] [--daemon-url <url>]
+
+Inspects daemon-managed provider configuration. This mirrors the deployment
+provider status endpoint: it reports whether a deployment provider is available,
+which protocol it fronts, its display label/host, and the default model.
+Provider credentials are never printed.
+
+Common options:
+  --daemon-url <url>   Open Design daemon HTTP base.
+  --json               Emit the raw redacted JSON response.`);
+}
+
 // ---------------------------------------------------------------------------
 // Subcommand: od amr …
 // ---------------------------------------------------------------------------

apps/daemon/src/connectionTest.ts

@@ -117,6 +117,9 @@ export { validateBaseUrl } from '@open-design/contracts/api/connectionTest';
 
 export type DnsLookupAddress = { address: string; family: number };
 export type DnsLookupFn = (hostname: string) => Promise<DnsLookupAddress[]>;
+export interface ResolvedBaseUrlValidationOptions extends ValidateBaseUrlOptions {
+  allowPrivateNetwork?: boolean;
+}
 
 const defaultDnsLookup: DnsLookupFn = async (hostname) => {
   const result = await dnsPromises.lookup(hostname, { all: true, family: 0 });
@@ -131,13 +134,29 @@ function looksLikeIpLiteral(hostname: string): boolean {
   return host.includes(':');
 }
 
+function validateConfiguredBaseUrl(baseUrl: string): BaseUrlValidationResult {
+  let parsed: ParsedBaseUrl;
+  try {
+    parsed = new URL(String(baseUrl).replace(/\/+$/, ''));
+  } catch {
+    return { error: 'Invalid baseUrl' };
+  }
+  if (!['http:', 'https:'].includes(parsed.protocol)) {
+    return { error: 'Only http/https allowed' };
+  }
+  return { parsed };
+}
+
 export async function validateBaseUrlResolved(
   baseUrl: string,
   lookup: DnsLookupFn = defaultDnsLookup,
-  options: ValidateBaseUrlOptions = {},
+  options: ResolvedBaseUrlValidationOptions = {},
 ): Promise<BaseUrlValidationResult> {
-  const sync = validateBaseUrl(baseUrl, options);
+  const sync = options.allowPrivateNetwork
+    ? validateConfiguredBaseUrl(baseUrl)
+    : validateBaseUrl(baseUrl, options);
   if (sync.error || !sync.parsed) return sync;
+  if (options.allowPrivateNetwork) return sync;
 
   const hostname = sync.parsed.hostname.toLowerCase();
   if (isLoopbackApiHost(hostname)) return sync;
@@ -729,7 +748,13 @@ export function redactSecrets(
   return redacted;
 }
 
-type ProviderConnectionInput = ProviderTestRequest & { signal?: AbortSignal };
+type ProviderConnectionInput = Omit<ProviderTestRequest, 'baseUrl' | 'apiKey'> & {
+  baseUrl: string;
+  apiKey: string;
+  metadata?: Record<string, unknown>;
+  signal?: AbortSignal;
+  allowPrivateNetworkBaseUrl?: boolean;
+};
 type AgentConnectionInput = AgentTestRequest & { signal?: AbortSignal };
 
 function appendVersionedApiPath(baseUrl: string, suffix: string): string {
@@ -1146,8 +1171,15 @@ interface ProviderCallShape {
   retryBodyOnUnsupportedMaxTokens?: unknown;
 }
 
+function metadataField(value: unknown): { metadata?: Record<string, unknown> } {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
+  return { metadata: value as Record<string, unknown> };
+}
+
 export function resolveOpenAIConnectionTestRunProviderPackage(
-  input: Pick<ProviderTestRequest, 'protocol' | 'baseUrl' | 'apiKey' | 'apiVersion' | 'model'>,
+  input: Pick<ProviderTestRequest, 'protocol' | 'baseUrl' | 'apiKey' | 'model'> & {
+    apiVersion?: ProviderTestRequest['apiVersion'];
+  },
 ): string | null {
   if (input.protocol !== 'openai') return null;
   const providerConfig = {
@@ -1172,6 +1204,7 @@ function openAIChatCompletionsProviderCall(
   baseUrl: string,
   apiKey: string,
   model: string,
+  metadata?: unknown,
 ): ProviderCallShape {
   return {
     url: appendVersionedApiPath(baseUrl, '/chat/completions'),
@@ -1185,6 +1218,7 @@ function openAIChatCompletionsProviderCall(
     },
     body: {
       model,
+      ...metadataField(metadata),
       ...buildOpenAIChatTokenParam(model, PROVIDER_MAX_TOKENS),
       messages: [{ role: 'user', content: SMOKE_PROMPT }],
       stream: false,
@@ -1197,6 +1231,7 @@ function openAIResponsesProviderCall(
   baseUrl: string,
   apiKey: string,
   model: string,
+  metadata?: unknown,
 ): ProviderCallShape {
   return {
     url: appendVersionedApiPath(baseUrl, '/responses'),
@@ -1206,6 +1241,7 @@ function openAIResponsesProviderCall(
     },
     body: {
       model,
+      ...metadataField(metadata),
       input: SMOKE_PROMPT,
       max_output_tokens: PROVIDER_MAX_TOKENS,
     },
@@ -1260,6 +1296,7 @@ function buildProviderCall(input: ProviderTestRequest): ProviderCallShape {
         },
         body: {
           model,
+          ...metadataField(input.metadata),
           ...buildOpenAIChatTokenParam(model, PROVIDER_MAX_TOKENS),
           messages: [{ role: 'user', content: SMOKE_PROMPT }],
           stream: false,
@@ -1276,13 +1313,13 @@ function buildProviderCall(input: ProviderTestRequest): ProviderCallShape {
       if (input.protocol === 'openai') {
         const runProviderPackage = resolveOpenAIConnectionTestRunProviderPackage(input);
         if (runProviderPackage === '@ai-sdk/openai') {
-          return openAIResponsesProviderCall(baseUrl, apiKey, model);
+          return openAIResponsesProviderCall(baseUrl, apiKey, model, input.metadata);
         }
         if (runProviderPackage === '@ai-sdk/openai-compatible') {
-          return openAIChatCompletionsProviderCall(baseUrl, apiKey, model);
+          return openAIChatCompletionsProviderCall(baseUrl, apiKey, model, input.metadata);
         }
       }
-      return openAIChatCompletionsProviderCall(baseUrl, apiKey, model);
+      return openAIChatCompletionsProviderCall(baseUrl, apiKey, model, input.metadata);
     case 'azure': {
       const url = new URL(baseUrl);
       const basePath = url.pathname.replace(/\/+$/, '');
@@ -1418,7 +1455,12 @@ export async function testProviderConnection(
   const start = Date.now();
   const model = String(input.model ?? '');
   const normalizedInput = normalizeProviderTestInput(input);
-  const validated = await validateUserProviderBaseUrl(normalizedInput.baseUrl);
+  const validated =
+    input.allowPrivateNetworkBaseUrl === true
+      ? await validateBaseUrlResolved(normalizedInput.baseUrl, undefined, {
+          allowPrivateNetwork: true,
+        })
+      : await validateUserProviderBaseUrl(normalizedInput.baseUrl);
   if (validated.error || !validated.parsed) {
     const kind: ConnectionTestKind = validated.forbidden ? 'forbidden' : 'invalid_base_url';
     return {