@build-astron-co/nimbus 0.2.0 → 0.4.0

package/src/config/profiles.ts

@@ -0,0 +1,84 @@
+/**
+ * Multi-account profile management.
+ *
+ * Profiles are stored at ~/.nimbus/profiles/<name>.json and merged into
+ * the app config at startup when --profile <name> is passed.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+export interface ConfigProfile {
+  name: string;
+  /** Anthropic API key for this profile */
+  anthropicApiKey?: string;
+  /** AWS profile name (maps to AWS_PROFILE env var) */
+  awsProfile?: string;
+  /** AWS region override */
+  awsRegion?: string;
+  /** GCP project ID */
+  gcpProject?: string;
+  /** Azure subscription ID */
+  azureSubscription?: string;
+  /** Default agent mode for this profile */
+  defaultMode?: string;
+}
+
+function getProfilesDir(): string {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? '/tmp';
+  return join(home, '.nimbus', 'profiles');
+}
+
+export function loadProfile(name: string): ConfigProfile | null {
+  const profilePath = join(getProfilesDir(), `${name}.json`);
+  if (!existsSync(profilePath)) return null;
+  try {
+    const raw = readFileSync(profilePath, 'utf-8');
+    return { name, ...JSON.parse(raw) } as ConfigProfile;
+  } catch {
+    return null;
+  }
+}
+
+export function saveProfile(profile: ConfigProfile): void {
+  const profilesDir = getProfilesDir();
+  mkdirSync(profilesDir, { recursive: true });
+  const { name, ...rest } = profile;
+  writeFileSync(join(profilesDir, `${name}.json`), JSON.stringify(rest, null, 2), 'utf-8');
+}
+
+export function listProfiles(): string[] {
+  const profilesDir = getProfilesDir();
+  if (!existsSync(profilesDir)) return [];
+  try {
+    return readdirSync(profilesDir)
+      .filter(f => f.endsWith('.json'))
+      .map(f => f.slice(0, -5));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Apply a profile to the current process environment.
+ * This mutates process.env so all subsequent operations pick up the profile.
+ */
+export function applyProfile(profile: ConfigProfile): void {
+  if (profile.anthropicApiKey) {
+    process.env.ANTHROPIC_API_KEY = profile.anthropicApiKey;
+  }
+  if (profile.awsProfile) {
+    process.env.AWS_PROFILE = profile.awsProfile;
+  }
+  if (profile.awsRegion) {
+    process.env.AWS_DEFAULT_REGION = profile.awsRegion;
+    process.env.AWS_REGION = profile.awsRegion;
+  }
+  if (profile.gcpProject) {
+    process.env.GCLOUD_PROJECT = profile.gcpProject;
+    process.env.GOOGLE_CLOUD_PROJECT = profile.gcpProject;
+  }
+  if (profile.azureSubscription) {
+    process.env.AZURE_SUBSCRIPTION_ID = profile.azureSubscription;
+  }
+}

package/src/config/types.ts

@@ -261,7 +261,11 @@ export type ConfigKey =
   | 'llm.cost_optimization.cheap_model'
   | 'llm.cost_optimization.expensive_model'
   | 'llm.cost_optimization.use_cheap_model_for'
-  | 'llm.cost_optimization.use_expensive_model_for';
+  | 'llm.cost_optimization.use_expensive_model_for'
+  | 'primaryClouds'
+  | 'model'
+  | 'defaultCostBudget'
+  | 'agentTurnTimeoutSeconds';
 
 /**
  * Config key metadata for help/validation
@@ -524,4 +528,82 @@ export const CONFIG_KEYS: ConfigKeyInfo[] = [
     description: 'Ordered list of fallback LLM providers to try on failure (JSON array)',
     type: 'string',
   },
+  // M4: Primary cloud providers
+  {
+    key: 'primaryClouds',
+    description: 'Primary cloud providers (comma-separated: aws,gcp,azure)',
+    type: 'string',
+  },
+  // M4: Model override (validated against known model IDs)
+  {
+    key: 'model',
+    description: 'Default model ID (e.g. claude-opus-4-6, claude-sonnet-4-6, claude-haiku-4-5-20251001)',
+    type: 'string',
+  },
+  // G16: Default cost budget per session
+  {
+    key: 'defaultCostBudget',
+    description: 'Default cost budget in USD per session (e.g. 1.00). 0 means unlimited.',
+    type: 'number',
+    defaultValue: 0,
+  },
+  // G21: Configurable agent turn silence timeout
+  {
+    key: 'agentTurnTimeoutSeconds',
+    description: 'Seconds to wait for LLM response before aborting (default: 60)',
+    type: 'number',
+    defaultValue: 60,
+  },
 ];
+
+// ---------------------------------------------------------------------------
+// M3: Per-project configuration (nimbus.yaml / .nimbus/config.json)
+// ---------------------------------------------------------------------------
+
+/**
+ * Per-project Nimbus configuration for team defaults.
+ * Stored in <project-root>/nimbus.yaml OR <project-root>/.nimbus/config.json.
+ * JSON-only format to avoid adding a YAML parser dependency.
+ */
+export interface ProjectConfig {
+  /** Default Terraform workspace for this project */
+  defaultWorkspace?: string;
+  /** Default kubectl context for this project */
+  defaultContext?: string;
+  /** Default Kubernetes namespace */
+  defaultNamespace?: string;
+  /** Tool call patterns to auto-approve (e.g. ["kubectl get *", "terraform plan"]) */
+  autoApprove?: string[];
+  /** Environment names that should be treated as protected (require confirmation for destructive ops) */
+  protectedEnvironments?: string[];
+}
+
+/**
+ * Load per-project configuration from:
+ *   1. <cwd>/nimbus.yaml  (JSON-parsed, no YAML dep)
+ *   2. <cwd>/.nimbus/config.json
+ *
+ * Returns null if neither file exists or both fail to parse.
+ */
+export function loadProjectConfig(cwd: string): ProjectConfig | null {
+  const { existsSync, readFileSync } = require('node:fs') as typeof import('node:fs');
+  const { join } = require('node:path') as typeof import('node:path');
+
+  const candidates = [
+    join(cwd, 'nimbus.yaml'),
+    join(cwd, '.nimbus', 'config.json'),
+  ];
+
+  for (const file of candidates) {
+    try {
+      if (!existsSync(file)) continue;
+      const raw = readFileSync(file, 'utf-8');
+      const parsed = JSON.parse(raw) as ProjectConfig;
+      return parsed;
+    } catch {
+      // Try next candidate
+    }
+  }
+
+  return null;
+}

package/src/config/workspace-state.ts

@@ -0,0 +1,53 @@
+/**
+ * Workspace state persistence — saves terraform workspace + kubectl context
+ * per working directory to ~/.nimbus/workspace-state.json
+ */
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+export interface WorkspaceState {
+  terraformWorkspace?: string;
+  kubectlContext?: string;
+  awsProfile?: string;
+  awsRegion?: string;
+  gcpProject?: string;
+  lastSeen?: string; // ISO timestamp
+}
+
+type StateFile = Record<string, WorkspaceState>; // keyed by cwd
+
+const STATE_PATH = join(homedir(), '.nimbus', 'workspace-state.json');
+
+function loadStateFile(): StateFile {
+  try {
+    return JSON.parse(readFileSync(STATE_PATH, 'utf-8')) as StateFile;
+  } catch {
+    return {};
+  }
+}
+
+function saveStateFile(state: StateFile): void {
+  try {
+    mkdirSync(join(homedir(), '.nimbus'), { recursive: true });
+    writeFileSync(STATE_PATH, JSON.stringify(state, null, 2), 'utf-8');
+  } catch { /* non-critical */ }
+}
+
+export function loadWorkspaceState(cwd: string): WorkspaceState {
+  const all = loadStateFile();
+  return all[cwd] ?? {};
+}
+
+export function saveWorkspaceState(cwd: string, state: WorkspaceState): void {
+  const all = loadStateFile();
+  all[cwd] = { ...all[cwd], ...state, lastSeen: new Date().toISOString() };
+  saveStateFile(all);
+}
+
+export function mergeWorkspaceState(cwd: string, infra: Partial<WorkspaceState>): WorkspaceState {
+  const existing = loadWorkspaceState(cwd);
+  const merged = { ...existing, ...infra };
+  saveWorkspaceState(cwd, merged);
+  return merged;
+}

package/src/engine/cost-estimator.ts

@@ -96,16 +96,58 @@ export interface CostEstimate {
  *   s3:  Minimal storage estimate (< 100GB) ~= $5
  */
 const BASE_COMPONENT_COSTS: Record<string, number> = {
-  vpc: 32, // NAT Gateway
-  eks: 73, // Control plane
-  rds: 50, // db.t3.micro + storage
-  s3: 5, // Minimal storage
-  ecs: 30, // Fargate minimal
-  lambda: 2, // < 1M invocations/month
-  cloudfront: 10, // < 1TB transfer/month
-  elasticache: 25, // cache.t3.micro
-  sqs: 1, // < 1M requests/month
-  sns: 1, // < 1M notifications/month
+  // AWS Compute
+  vpc: 32,
+  eks: 73,
+  ecs: 30,
+  lambda: 2,
+  // EC2 instance types (monthly on-demand us-east-1)
+  't3.micro': 8,
+  't3.small': 16,
+  't3.medium': 32,
+  't3.large': 65,
+  'm5.large': 70,
+  'm5.xlarge': 140,
+  'm5.2xlarge': 280,
+  'c5.large': 62,
+  'c5.xlarge': 124,
+  'r5.large': 91,
+  'r5.xlarge': 182,
+  // RDS instance types (monthly, single-AZ)
+  'db.t3.micro': 14,
+  'db.t3.small': 28,
+  'db.t3.medium': 56,
+  'db.r5.large': 175,
+  'db.r5.xlarge': 350,
+  // AWS Data
+  rds: 50,
+  s3: 5,
+  elasticache: 25,
+  sqs: 1,
+  sns: 1,
+  cloudfront: 10,
+  // AWS Network/LB
+  'aws_nat_gateway': 32,
+  'aws_lb': 25,
+  'aws_alb': 25,
+  'aws_instance': 30,
+  'aws_db_instance': 50,
+  'aws_s3_bucket': 5,
+  'aws_eks_cluster': 73,
+  'aws_elasticache_cluster': 25,
+  'aws_rds_cluster': 50,
+  'aws_lambda_function': 2,
+  'aws_cloudfront_distribution': 10,
+  // GCP
+  'google_compute_instance': 30,
+  'google_container_cluster': 73,
+  'google_sql_database_instance': 50,
+  'google_storage_bucket': 5,
+  // Azure
+  'azurerm_virtual_machine': 30,
+  'azurerm_kubernetes_cluster': 73,
+  'azurerm_sql_database': 50,
+  'azurerm_storage_account': 5,
 };
 
 /**

package/src/engine/executor.ts

@@ -917,8 +917,39 @@ export class Executor {
       // Execute rollback action
       this.log(executionId, 'info', `Executing rollback: ${step.rollback_action}`);
 
-      // Simulate rollback
-      await this.sleep(1000);
+      // Parse and execute the rollback action
+      const action = step.rollback_action;
+      const [prefix, ...rest] = action.split(':');
+      
+      let rollbackCmd: string;
+      if (prefix === 'terraform_destroy') {
+        const workdir = rest.join(':');
+        rollbackCmd = `terraform -chdir=${workdir} destroy -auto-approve -no-color`;
+      } else if (prefix === 'kubectl_rollout_undo') {
+        const [resource, namespace] = rest;
+        rollbackCmd = `kubectl rollout undo ${resource}${namespace ? ` -n ${namespace}` : ''}`;
+      } else if (prefix === 'helm_rollback') {
+        const [release, revision, namespace] = rest;
+        rollbackCmd = `helm rollback ${release} ${revision ?? '0'}${namespace ? ` -n ${namespace}` : ''}`;
+      } else if (prefix === 'bash') {
+        rollbackCmd = rest.join(':');
+      } else {
+        this.log(executionId, 'warn', `Unknown rollback prefix "${prefix}" — skipping`);
+        rollbackCmd = '';
+      }
+      
+      if (rollbackCmd) {
+        this.log(executionId, 'info', `Running: ${rollbackCmd}`);
+        await new Promise<void>((resolve, reject) => {
+          const { exec } = require('node:child_process') as typeof import('node:child_process');
+          exec(rollbackCmd, { timeout: 600_000 }, (error, stdout, stderr) => {
+            if (stdout) this.log(executionId, 'info', stdout);
+            if (stderr) this.log(executionId, 'info', stderr);
+            if (error) reject(error);
+            else resolve();
+          });
+        });
+      }
 
       const completedAt = new Date();
 

package/src/engine/planner.ts

@@ -115,6 +115,17 @@ const VALID_CATEGORIES = new Set(['security', 'cost', 'availability', 'performan
 // Planner
 // ==========================================
 
+/** Detect the primary domain of a task description. */
+function detectDomain(task: AgentTask): 'terraform' | 'kubernetes' | 'helm' | 'generic' {
+  const desc = (task.type + ' ' + JSON.stringify(task.context)).toLowerCase();
+  if (desc.includes('helm') || desc.includes('chart') || desc.includes('release')) return 'helm';
+  if (desc.includes('kubectl') || desc.includes('kubernetes') || desc.includes('pod') || desc.includes('deployment') || desc.includes('k8s')) return 'kubernetes';
+  if (desc.includes('terraform') || desc.includes('.tf') || desc.includes('infrastructure') || desc.includes('provider')) return 'terraform';
+  // Default to terraform for infrastructure tasks
+  if (task.type === 'deploy' || task.type === 'generate') return 'terraform';
+  return 'generic';
+}
+
 export class Planner {
   private router: LLMRouter;
 
@@ -230,6 +241,16 @@ export class Planner {
     const steps: PlanStep[] = [];
     let order = 1;
 
+    // Domain-specific step generation
+    const domain = detectDomain(task);
+    if (domain === 'terraform') {
+      return this.generateTerraformSteps(task);
+    } else if (domain === 'kubernetes') {
+      return this.generateKubernetesSteps(task);
+    } else if (domain === 'helm') {
+      return this.generateHelmSteps(task);
+    }
+
     // Step 1: Validate requirements
     steps.push({
       id: `step_${order++}`,
@@ -325,7 +346,7 @@ export class Planner {
         },
         status: 'pending',
         depends_on: [steps[steps.length - 1].id],
-        rollback_action: 'destroy_deployment',
+        rollback_action: `terraform_destroy:${task.context.environment ?? '.'}` as string,
         rollback_parameters: {
           provider: task.context.provider,
           environment: task.context.environment,
@@ -366,6 +387,52 @@ export class Planner {
     return steps;
   }
 
+  private generateTerraformSteps(task: AgentTask): PlanStep[] {
+    const steps: PlanStep[] = [];
+    let order = 1;
+    const env = task.context.environment ?? '.';
+    steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'validate', description: 'terraform init — initialize providers and modules', action: 'terraform_init', parameters: { workdir: env }, status: 'pending' });
+    steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'validate', description: 'terraform validate — check configuration syntax', action: 'terraform_validate', parameters: { workdir: env }, status: 'pending', depends_on: ['step_1'] });
+    steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'validate', description: 'terraform plan — preview changes', action: 'terraform_plan', parameters: { workdir: env }, status: 'pending', depends_on: ['step_2'] });
+    steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'validate', description: 'Review plan output with human', action: 'review_plan', parameters: { workdir: env }, status: 'pending', depends_on: ['step_3'] });
+    if (task.type === 'deploy') {
+      steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'deploy', description: 'terraform apply — apply approved changes', action: 'terraform_apply', parameters: { workdir: env }, status: 'pending', depends_on: ['step_4'], rollback_action: `terraform_destroy:${env}`, rollback_parameters: { workdir: env } });
+      steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'validate', description: 'terraform output — capture outputs', action: 'terraform_output', parameters: { workdir: env }, status: 'pending', depends_on: ['step_5'] });
+      steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'verify', description: 'Verify deployed infrastructure resources', action: 'verify_infra', parameters: { workdir: env }, status: 'pending', depends_on: ['step_6'] });
+    }
+    return steps;
+  }
+
+  private generateKubernetesSteps(task: AgentTask): PlanStep[] {
+    const steps: PlanStep[] = [];
+    let order = 1;
+    const env = task.context.environment ?? '.';
+    steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'validate', description: 'Validate Kubernetes manifests (dry-run client)', action: 'kubectl_dry_run', parameters: { workdir: env }, status: 'pending' });
+    steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'validate', description: 'kubectl diff — show what would change', action: 'kubectl_diff', parameters: { workdir: env }, status: 'pending', depends_on: ['step_1'] });
+    if (task.type === 'deploy') {
+      steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'deploy', description: 'kubectl apply — deploy manifests', action: 'kubectl_apply', parameters: { workdir: env }, status: 'pending', depends_on: ['step_2'], rollback_action: 'kubectl_rollout_undo:deployment/app:default' });
+      steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'verify', description: 'kubectl rollout status — wait for rollout', action: 'kubectl_rollout_status', parameters: { workdir: env }, status: 'pending', depends_on: ['step_3'] });
+      steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'verify', description: 'Verify all pods are running', action: 'verify_pods', parameters: { workdir: env }, status: 'pending', depends_on: ['step_4'] });
+    }
+    return steps;
+  }
+
+  private generateHelmSteps(task: AgentTask): PlanStep[] {
+    const steps: PlanStep[] = [];
+    let order = 1;
+    const release = task.context.components[0] ?? 'app';
+    const ns = task.context.environment ?? 'default';
+    steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'validate', description: 'helm lint — validate chart templates', action: 'helm_lint', parameters: { release, namespace: ns }, status: 'pending' });
+    steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'validate', description: 'helm template — render and preview manifests', action: 'helm_template', parameters: { release, namespace: ns }, status: 'pending', depends_on: ['step_1'] });
+    if (task.type === 'deploy') {
+      steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'validate', description: 'helm diff upgrade — show what would change', action: 'helm_diff', parameters: { release, namespace: ns }, status: 'pending', depends_on: ['step_2'] });
+      steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'deploy', description: 'helm upgrade --install --atomic — deploy release', action: 'helm_upgrade', parameters: { release, namespace: ns }, status: 'pending', depends_on: ['step_3'], rollback_action: `helm_rollback:${release}:0:${ns}` });
+      steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'verify', description: 'helm test — run chart tests', action: 'helm_test', parameters: { release, namespace: ns }, status: 'pending', depends_on: ['step_4'] });
+      steps.push({ id: `step_${order++}`, order: steps.length + 1, type: 'verify', description: 'Verify release is deployed and healthy', action: 'verify_release', parameters: { release, namespace: ns }, status: 'pending', depends_on: ['step_5'] });
+    }
+    return steps;
+  }
+
   /**
    * Analyze dependencies between steps
    */

package/src/generator/terraform.ts

@@ -1865,3 +1865,11 @@ output "alias_arn" {
     }
   }
 }
+
+/**
+ * Convenience function — instantiate the generator and run it.
+ * Used by generate-terraform.ts and aws-terraform.ts.
+ */
+export async function generateTerraformProject(config: TerraformProjectConfig): Promise<GeneratedProject> {
+  return new TerraformProjectGenerator().generate(config);
+}

package/src/history/manager.ts

@@ -40,11 +40,9 @@ function createEmptyHistoryFile(): HistoryFile {
 export class HistoryManager {
   private historyPath: string;
   private historyFile: HistoryFile | null = null;
-  private stateServiceUrl: string;
 
   constructor(historyPath?: string) {
     this.historyPath = historyPath || path.join(os.homedir(), '.nimbus', 'history.json');
-    this.stateServiceUrl = process.env.STATE_SERVICE_URL || 'http://localhost:3004';
   }
 
   /**
@@ -118,66 +116,6 @@ export class HistoryManager {
     fs.writeFileSync(this.historyPath, content, { mode: 0o600 });
   }
 
-  /**
-   * Sync a history entry to the remote State Service.
-   * Fire-and-forget: never throws on network or parse errors.
-   */
-  private async syncToStateService(entry: HistoryEntry): Promise<void> {
-    try {
-      await fetch(`${this.stateServiceUrl}/api/state/history`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(entry),
-      });
-    } catch {
-      // Fire-and-forget: swallow all errors silently
-      console.warn('[nimbus] Failed to sync history entry to State Service');
-    }
-  }
-
-  /**
-   * Load history entries from the remote State Service.
-   * Returns the entries array on success, or null on any failure
-   * so the caller can fall back to local storage.
-   */
-  private async loadFromStateService(options: HistoryQueryOptions): Promise<HistoryEntry[] | null> {
-    try {
-      const params = new URLSearchParams();
-      if (options.limit !== undefined) {
-        params.set('limit', String(options.limit));
-      }
-      if (options.since) {
-        params.set('since', options.since);
-      }
-      if (options.until) {
-        params.set('until', options.until);
-      }
-      if (options.command) {
-        params.set('command', options.command);
-      }
-      if (options.status) {
-        params.set('status', options.status);
-      }
-
-      const queryString = params.toString();
-      const url = `${this.stateServiceUrl}/api/state/history${queryString ? `?${queryString}` : ''}`;
-
-      const response = await fetch(url);
-      if (!response.ok) {
-        return null;
-      }
-
-      const body = (await response.json()) as { success?: boolean; data?: HistoryEntry[] };
-      if (body.success && Array.isArray(body.data)) {
-        return body.data;
-      }
-      return null;
-    } catch {
-      // Network error, parse error, etc. — fall back to local
-      return null;
-    }
-  }
-
   /**
    * Add a new entry to history
    */
@@ -202,9 +140,6 @@ export class HistoryManager {
 
     this.save(historyFile);
 
-    // Fire-and-forget: sync to State Service without blocking
-    this.syncToStateService(entry).catch(() => {});
-
     return entry;
   }
 
@@ -245,17 +180,10 @@ export class HistoryManager {
 
   /**
    * Get history entries with optional filtering.
-   * Attempts to load from the remote State Service first;
-   * falls back to local file storage on any failure.
+   * Reads from local file storage.
    */
   async getEntries(options: HistoryQueryOptions = {}): Promise<HistoryEntry[]> {
-    // Try remote State Service first
-    const remoteEntries = await this.loadFromStateService(options);
-    if (remoteEntries !== null) {
-      return remoteEntries;
-    }
-
-    // Fall back to local file
+    // Read from local file
     const historyFile = this.load();
     let entries = [...historyFile.entries];
 

package/src/hooks/engine.ts

@@ -242,13 +242,14 @@ export class HookEngine {
       }
 
       // Write context JSON to stdin
-      try {
-        if (child.stdin) {
+      if (child.stdin) {
+        child.stdin.on('error', () => { /* EPIPE or other write errors — ignore */ });
+        try {
           child.stdin.write(JSON.stringify(context));
           child.stdin.end();
+        } catch {
+          // stdin may already be closed -- ignore
         }
-      } catch {
-        // stdin may already be closed -- ignore
       }
 
       // Collect stdout and stderr

package/src/llm/cost-calculator.ts

@@ -138,13 +138,13 @@ export function calculateCost(
 
   const providerPricing = PRICING[provider];
   if (!providerPricing) {
-    logger.warn(`No pricing data for provider "${provider}", returning zero cost`);
+    logger.debug(`No pricing data for provider "${provider}", returning zero cost`);
     return { costUSD: 0, breakdown: { input: 0, output: 0 } };
   }
 
   const entry = providerPricing[model];
   if (!entry) {
-    logger.warn(
+    logger.debug(
       `No pricing data for model "${model}" on provider "${provider}", returning zero cost`
     );
     return { costUSD: 0, breakdown: { input: 0, output: 0 } };