@ryanfw/prompt-orchestration-pipeline 0.14.2 → 0.15.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanfw/prompt-orchestration-pipeline",
-  "version": "0.14.2",
+  "version": "0.15.1",
   "description": "A Prompt-orchestration pipeline (POP) is a framework for building, running, and experimenting with complex chains of LLM tasks.",
   "type": "module",
   "main": "src/ui/server.js",

package/src/core/orchestrator.js

@@ -123,10 +123,8 @@ export async function startOrchestrator(opts) {
     } catch {}
 
     // Move seed to current/{jobId}/seed.json
-    logger.log("Moving file", { from: filePath, to: dest });
     try {
       await moveFile(filePath, dest);
-      logger.log("Successfully moved file", { destination: dest });
     } catch (error) {
       logger.error("Failed to move file", {
         from: filePath,
@@ -173,12 +171,6 @@ export async function startOrchestrator(opts) {
         // Apply artifact initialization to the status
         const updatedStatus = applyArtifacts(status);
         await fs.writeFile(statusPath, JSON.stringify(updatedStatus, null, 2));
-
-        logger.log("Initialized status from upload artifacts", {
-          jobId,
-          pipeline: seed?.pipeline,
-          artifactsCount: updatedStatus.files?.artifacts?.length || 0,
-        });
       } catch (artifactError) {
         // Don't fail job startup if artifact initialization fails, just log
         logger.warn("Failed to initialize status from artifacts", {
@@ -233,7 +225,6 @@ export async function startOrchestrator(opts) {
 
   // Watch pending directory for seeds
   const watchPattern = path.join(dirs.pending, "*.json");
-  logger.log("Watching pattern", { pattern: watchPattern });
   const watcher = watcherFactory(watchPattern, {
     ignoreInitial: false,
     awaitWriteFinish: false, // Disable awaitWriteFinish for faster detection
@@ -243,7 +234,6 @@ export async function startOrchestrator(opts) {
   // Wait for watcher to be ready before resolving
   await new Promise((resolve, reject) => {
     watcher.on("ready", () => {
-      logger.log("Watcher is ready");
       resolve();
     });
 
@@ -254,7 +244,6 @@ export async function startOrchestrator(opts) {
   });
 
   watcher.on("add", (file) => {
-    logger.log("Detected file add", { file });
     // Return promise so tests awaiting the add handler block until processing completes
     return handleSeedAdd(file);
   });
@@ -330,13 +319,6 @@ function spawnRunner(
     const availablePipelines = Object.keys(configSnapshot?.pipelines ?? {});
     const pipelineSlug = seed?.pipeline;
 
-    logger.log("spawnRunner invoked", {
-      jobId,
-      pipelineSlug: pipelineSlug ?? null,
-      availablePipelines,
-      seedKeys: seed ? Object.keys(seed) : null,
-    });
-
     if (!availablePipelines.length) {
       logger.warn(
         "No pipelines registered in config() when spawnRunner invoked"

package/src/core/pipeline-runner.js

@@ -143,10 +143,6 @@ try {
       startFromTask &&
       taskNames.indexOf(taskName) < taskNames.indexOf(startFromTask)
     ) {
-      logger.log("Skipping task before restart point", {
-        taskName,
-        startFromTask,
-      });
       continue;
     }
 
@@ -155,7 +151,6 @@ try {
         const outputPath = path.join(workDir, "tasks", taskName, "output.json");
         const output = JSON.parse(await fs.readFile(outputPath, "utf8"));
         pipelineArtifacts[taskName] = output;
-        logger.log("Task already completed", { taskName });
       } catch {
         logger.warn("Failed to read completed task output", { taskName });
       }
@@ -190,7 +185,6 @@ try {
       }
     }
 
-    logger.log("Starting task", { taskName });
     await updateStatus(taskName, {
       state: TaskState.RUNNING,
       startedAt: now(),
@@ -265,13 +259,6 @@ try {
           process.exitCode = 1;
           process.exit(1);
         }
-
-        logger.log("Task symlinks repaired successfully", {
-          taskName,
-          taskDir,
-          repairDuration: repairResult.duration,
-          relocatedEntry: repairResult.relocatedEntry,
-        });
       } else {
         logger.debug("Task symlinks validation passed", {
           taskName,
@@ -295,7 +282,6 @@ try {
         statusPath: tasksStatusPath,
       });
 
-      logger.log("Running task", { taskName, modulePath: absoluteModulePath });
       const result = await runPipeline(relocatedEntry, ctx);
 
       if (!result.ok) {
@@ -363,13 +349,6 @@ try {
         process.exit(1);
       }
 
-      logger.log("Task completed successfully", {
-        taskName,
-        executionTimeMs:
-          result.logs?.reduce((total, log) => total + (log.ms || 0), 0) || 0,
-        refinementAttempts: result.refinementAttempts || 0,
-      });
-
       // The file I/O system automatically handles writing outputs and updating tasks-status.json
       // No need to manually write output.json or enumerate artifacts
 
@@ -396,7 +375,6 @@ try {
 
       // Check if this is a single task run and we've completed the target task
       if (runSingleTask && taskName === startFromTask) {
-        logger.log("Stopping after single task execution", { taskName });
         break;
       }
     } catch (err) {
@@ -415,19 +393,6 @@ try {
     await fs.mkdir(COMPLETE_DIR, { recursive: true });
     const dest = path.join(COMPLETE_DIR, jobId);
 
-    logger.log("Pipeline completed", {
-      jobId,
-      totalExecutionTime: Object.values(status.tasks).reduce(
-        (total, t) => total + (t.executionTimeMs || 0),
-        0
-      ),
-      totalRefinementAttempts: Object.values(status.tasks).reduce(
-        (total, t) => total + (t.refinementAttempts || 0),
-        0
-      ),
-      finalArtifacts: Object.keys(pipelineArtifacts),
-    });
-
     await fs.rename(workDir, dest);
     await appendLine(
       path.join(COMPLETE_DIR, "runs.jsonl"),
@@ -449,8 +414,6 @@ try {
 
     // Clean up task symlinks to avoid dangling links in archives
     await cleanupTaskSymlinks(dest);
-  } else {
-    logger.log("Single task run completed, job remains in current", { jobId });
   }
 } catch (error) {
   throw error;

package/src/core/status-writer.js

@@ -164,13 +164,8 @@ export async function writeJobStatus(jobDir, updateFn) {
 
   const next = prev
     .then(async () => {
-      logger.group("Status Write Operation");
-      logger.log(`Updating status for job: ${jobId}`);
-      logger.log(`Status file path: ${statusPath}`);
-
       // Read existing status or create default
       const current = await readStatusFile(statusPath, jobId);
-      logger.log("Current status snapshot:", current);
 
       // Validate basic structure
       const validated = validateStatusSnapshot(current);
@@ -188,11 +183,9 @@ export async function writeJobStatus(jobDir, updateFn) {
       );
 
       snapshot.lastUpdated = new Date().toISOString();
-      logger.log("Status after update function:", snapshot);
 
       // Atomic write
       await atomicWrite(statusPath, snapshot);
-      logger.log("Status file written successfully");
 
       // Emit SSE event for tasks-status.json change using logger
       try {
@@ -202,7 +195,6 @@ export async function writeJobStatus(jobDir, updateFn) {
           jobId,
         };
         await logger.sse("state:change", eventData);
-        logger.log("SSE event broadcasted successfully");
       } catch (error) {
         // Don't fail the write if SSE emission fails
         logger.error("Failed to emit SSE event:", error);
@@ -218,10 +210,6 @@ export async function writeJobStatus(jobDir, updateFn) {
             reason: snapshot.lifecycleBlockReason,
           };
           await logger.sse("lifecycle_block", lifecycleEventData);
-          logger.log(
-            "lifecycle_block SSE event broadcasted successfully",
-            lifecycleEventData
-          );
         } catch (error) {
           // Don't fail the write if SSE emission fails
           logger.error("Failed to emit lifecycle_block SSE event:", error);
@@ -310,9 +298,6 @@ export async function updateTaskStatus(jobDir, taskId, taskUpdateFn) {
 
   const next = prev
     .then(async () => {
-      logger.group("Task Status Update Operation");
-      logger.log(`Updating task ${taskId} for job: ${jobId}`);
-
       const statusPath = path.join(jobDir, "tasks-status.json");
 
       // Read existing status or create default
@@ -336,7 +321,6 @@ export async function updateTaskStatus(jobDir, taskId, taskUpdateFn) {
 
       // Atomic write
       await atomicWrite(statusPath, validated);
-      logger.log("Task status file written successfully");
 
       // Emit task:updated SSE event after successful write
       try {
@@ -346,13 +330,11 @@ export async function updateTaskStatus(jobDir, taskId, taskUpdateFn) {
           task: validated.tasks[taskId],
         };
         await logger.sse("task:updated", eventData);
-        logger.log("task:updated SSE event broadcasted successfully");
       } catch (error) {
         // Don't fail the write if SSE emission fails
         logger.error("Failed to emit task:updated SSE event:", error);
       }
 
-      logger.groupEnd();
       resultSnapshot = validated;
     })
     .catch((e) => {

package/src/core/symlink-utils.js

@@ -196,12 +196,6 @@ export async function repairTaskSymlinks(taskDir, poRoot, taskModulePath) {
   const startTime = Date.now();
 
   try {
-    logger.log("Repairing task symlinks", {
-      taskDir,
-      poRoot,
-      taskModulePath,
-    });
-
     // Use existing ensureTaskSymlinkBridge for repairs
     const relocatedEntry = await ensureTaskSymlinkBridge({
       taskDir,
@@ -211,12 +205,6 @@ export async function repairTaskSymlinks(taskDir, poRoot, taskModulePath) {
 
     const duration = Date.now() - startTime;
 
-    logger.log("Task symlinks repaired successfully", {
-      taskDir,
-      duration,
-      relocatedEntry,
-    });
-
     return {
       success: true,
       relocatedEntry,

package/src/core/task-runner.js

@@ -484,10 +484,6 @@ export async function runPipeline(modulePath, initialContext = {}) {
 
     // Skip stages when skipIf predicate returns true
     if (stageConfig.skipIf && stageConfig.skipIf(context.flags)) {
-      logger.log("Skipping stage", {
-        stage: stageName,
-        reason: "skipIf predicate returned true",
-      });
       context.logs.push({
         stage: stageName,
         action: "skipped",
@@ -499,7 +495,6 @@ export async function runPipeline(modulePath, initialContext = {}) {
 
     // Skip if handler is not available (not implemented)
     if (typeof stageHandler !== "function") {
-      logger.log("Stage not available, skipping", { stage: stageName });
       logs.push({
         stage: stageName,
         skipped: true,
@@ -526,11 +521,6 @@ export async function runPipeline(modulePath, initialContext = {}) {
     // Set current stage before execution
     context.currentStage = stageName;
 
-    logger.log("Starting stage execution", {
-      stage: stageName,
-      taskName: context.meta.taskName,
-    });
-
     // Write stage start status using writeJobStatus
     if (context.meta.workDir && context.meta.taskName) {
       try {
@@ -719,12 +709,6 @@ export async function runPipeline(modulePath, initialContext = {}) {
       );
 
       const ms = +(performance.now() - start).toFixed(2);
-      logger.log("Stage completed successfully", {
-        stage: stageName,
-        executionTimeMs: ms,
-        outputType: typeof stageResult.output,
-        flagKeys: Object.keys(stageResult.flags),
-      });
       logs.push({
         stage: stageName,
         ok: true,
@@ -819,13 +803,6 @@ export async function runPipeline(modulePath, initialContext = {}) {
 
   llmEvents.off("llm:request:complete", onLLMComplete);
 
-  logger.log("Pipeline completed successfully", {
-    taskName: context.meta.taskName,
-    totalStages: PIPELINE_STAGES.length,
-    executedStages: logs.filter((l) => l.ok).length,
-    llmMetricsCount: llmMetrics.length,
-  });
-
   // Write final status with currentStage: null to indicate completion
   if (context.meta.workDir && context.meta.taskName) {
     try {

package/src/llm/index.js

@@ -11,6 +11,9 @@ import {
   aliasToFunctionName,
 } from "../config/models.js";
 import fs from "node:fs";
+import { createLogger } from "../core/logger.js";
+
+const logger = createLogger("LLM");
 
 // Global mock provider instance (for demo/testing)
 let mockProviderInstance = null;
@@ -103,7 +106,7 @@ function shouldInferJsonFormat(messages) {
 
 // Core chat function - no metrics handling needed!
 export async function chat(options) {
-  console.log("[llm] chat() called with options:", {
+  logger.log("chat() called with options:", {
     provider: options.provider,
     model: options.model,
     messageCount: options.messages?.length || 0,
@@ -133,11 +136,11 @@ export async function chat(options) {
 
   const available = getAvailableProviders();
 
-  console.log("[llm] Available providers:", available);
-  console.log("[llm] Requested provider:", provider);
+  logger.log("Available providers:", available);
+  logger.log("Requested provider:", provider);
 
   if (!available[provider]) {
-    console.error("[llm] Provider not available:", provider);
+    logger.error("Provider not available:", provider);
     throw new Error(`Provider ${provider} not available. Check API keys.`);
   }
 
@@ -149,7 +152,7 @@ export async function chat(options) {
   const userMessages = messages.filter((m) => m.role === "user");
   const userMsg = userMessages.map((m) => m.content).join("\n");
 
-  console.log("[llm] Message analysis:", {
+  logger.log("Message analysis:", {
     hasSystemMessage: !!systemMsg,
     systemMessageLength: systemMsg.length,
     userMessageCount: userMessages.length,
@@ -163,10 +166,7 @@ export async function chat(options) {
     JSON.stringify({ messages, systemMsg, userMsg, provider, model }, null, 2)
   );
 
-  console.log(
-    "[llm] Emitting llm:request:start event for requestId:",
-    requestId
-  );
+  logger.log("Emitting llm:request:start event for requestId:", requestId);
 
   // Emit request start event
   llmEvents.emit("llm:request:start", {
@@ -178,12 +178,12 @@ export async function chat(options) {
   });
 
   try {
-    console.log("[llm] Starting provider call for:", provider);
+    logger.log("Starting provider call for:", provider);
     let response;
     let usage;
 
     if (provider === "mock") {
-      console.log("[llm] Using mock provider");
+      logger.log("Using mock provider");
       if (!mockProviderInstance) {
         throw new Error(
           "Mock provider not registered. Call registerMockProvider() first."
@@ -197,7 +197,7 @@ export async function chat(options) {
         maxTokens,
         ...rest,
       });
-      console.log("[llm] Mock provider returned result");
+      logger.log("Mock provider returned result");
 
       response = {
         content: result.content,
@@ -210,7 +210,7 @@ export async function chat(options) {
         totalTokens: result.usage.total_tokens,
       };
     } else if (provider === "openai") {
-      console.log("[llm] Using OpenAI provider");
+      logger.log("Using OpenAI provider");
 
       // Infer JSON format if not explicitly provided
       const effectiveResponseFormat =
@@ -229,7 +229,7 @@ export async function chat(options) {
         maxTokens,
         ...rest,
       };
-      console.log("[llm] OpenAI call parameters:", {
+      logger.log("OpenAI call parameters:", {
         model: openaiArgs.model,
         hasMessages: !!openaiArgs.messages,
         messageCount: openaiArgs.messages?.length,
@@ -244,9 +244,9 @@ export async function chat(options) {
         openaiArgs.presencePenalty = presencePenalty;
       if (stop !== undefined) openaiArgs.stop = stop;
 
-      console.log("[llm] Calling openaiChat()...");
+      logger.log("Calling openaiChat()...");
       const result = await openaiChat(openaiArgs);
-      console.log("[llm] openaiChat() returned:", {
+      logger.log("openaiChat() returned:", {
         hasResult: !!result,
         hasContent: !!result?.content,
         hasUsage: !!result?.usage,
@@ -277,7 +277,7 @@ export async function chat(options) {
         };
       }
     } else if (provider === "deepseek") {
-      console.log("[llm] Using DeepSeek provider");
+      logger.log("Using DeepSeek provider");
 
       // Infer JSON format if not explicitly provided
       const effectiveResponseFormat =
@@ -296,7 +296,7 @@ export async function chat(options) {
         maxTokens,
         ...rest,
       };
-      console.log("[llm] DeepSeek call parameters:", {
+      logger.log("DeepSeek call parameters:", {
         model: deepseekArgs.model,
         hasMessages: !!deepseekArgs.messages,
         messageCount: deepseekArgs.messages?.length,
@@ -312,9 +312,9 @@ export async function chat(options) {
         deepseekArgs.responseFormat = effectiveResponseFormat;
       }
 
-      console.log("[llm] Calling deepseekChat()...");
+      logger.log("Calling deepseekChat()...");
       const result = await deepseekChat(deepseekArgs);
-      console.log("[llm] deepseekChat() returned:", {
+      logger.log("deepseekChat() returned:", {
         hasResult: !!result,
         isStream: typeof result?.[Symbol.asyncIterator] !== "undefined",
         hasContent: !!result?.content,
@@ -350,7 +350,7 @@ export async function chat(options) {
         };
       }
     } else if (provider === "anthropic") {
-      console.log("[llm] Using Anthropic provider");
+      logger.log("Using Anthropic provider");
       const defaultAlias = DEFAULT_MODEL_BY_PROVIDER.anthropic;
       const defaultModelConfig = MODEL_CONFIG[defaultAlias];
       const defaultModel = defaultModelConfig?.model;
@@ -362,7 +362,7 @@ export async function chat(options) {
         maxTokens,
         ...rest,
       };
-      console.log("[llm] Anthropic call parameters:", {
+      logger.log("Anthropic call parameters:", {
         model: anthropicArgs.model,
         hasMessages: !!anthropicArgs.messages,
         messageCount: anthropicArgs.messages?.length,
@@ -373,9 +373,9 @@ export async function chat(options) {
         anthropicArgs.responseFormat = responseFormat;
       }
 
-      console.log("[llm] Calling anthropicChat()...");
+      logger.log("Calling anthropicChat()...");
       const result = await anthropicChat(anthropicArgs);
-      console.log("[llm] anthropicChat() returned:", {
+      logger.log("anthropicChat() returned:", {
         hasResult: !!result,
         hasContent: !!result?.content,
         hasUsage: !!result?.usage,
@@ -406,7 +406,7 @@ export async function chat(options) {
         };
       }
     } else if (provider === "gemini") {
-      console.log("[llm] Using Gemini provider");
+      logger.log("Using Gemini provider");
 
       // Infer JSON format if not explicitly provided
       const effectiveResponseFormat =
@@ -425,7 +425,7 @@ export async function chat(options) {
         maxTokens,
         ...rest,
       };
-      console.log("[llm] Gemini call parameters:", {
+      logger.log("Gemini call parameters:", {
         model: geminiArgs.model,
         hasMessages: !!geminiArgs.messages,
         messageCount: geminiArgs.messages?.length,
@@ -436,9 +436,9 @@ export async function chat(options) {
         geminiArgs.responseFormat = effectiveResponseFormat;
       }
 
-      console.log("[llm] Calling geminiChat()...");
+      logger.log("Calling geminiChat()...");
       const result = await geminiChat(geminiArgs);
-      console.log("[llm] geminiChat() returned:", {
+      logger.log("geminiChat() returned:", {
         hasResult: !!result,
         hasContent: !!result?.content,
         hasUsage: !!result?.usage,
@@ -469,7 +469,7 @@ export async function chat(options) {
         };
       }
     } else if (provider === "zhipu") {
-      console.log("[llm] Using Zhipu provider");
+      logger.log("Using Zhipu provider");
       const defaultAlias = DEFAULT_MODEL_BY_PROVIDER.zhipu;
       const defaultModelConfig = MODEL_CONFIG[defaultAlias];
       const defaultModel = defaultModelConfig?.model;
@@ -481,7 +481,7 @@ export async function chat(options) {
         maxTokens,
         ...rest,
       };
-      console.log("[llm] Zhipu call parameters:", {
+      logger.log("Zhipu call parameters:", {
         model: zhipuArgs.model,
         hasMessages: !!zhipuArgs.messages,
         messageCount: zhipuArgs.messages?.length,
@@ -492,9 +492,9 @@ export async function chat(options) {
         zhipuArgs.responseFormat = responseFormat;
       }
 
-      console.log("[llm] Calling zhipuChat()...");
+      logger.log("Calling zhipuChat()...");
       const result = await zhipuChat(zhipuArgs);
-      console.log("[llm] zhipuChat() returned:", {
+      logger.log("zhipuChat() returned:", {
         hasResult: !!result,
         hasContent: !!result?.content,
         hasUsage: !!result?.usage,
@@ -525,16 +525,16 @@ export async function chat(options) {
         };
       }
     } else {
-      console.error("[llm] Unknown provider:", provider);
+      logger.error("Unknown provider:", provider);
       throw new Error(`Provider ${provider} not yet implemented`);
     }
 
-    console.log("[llm] Processing response from provider:", provider);
+    logger.log("Processing response from provider:", provider);
 
     const duration = Date.now() - startTime;
     const cost = calculateCost(provider, model, usage);
 
-    console.log("[llm] Request completed:", {
+    logger.log("Request completed:", {
       duration: `${duration}ms`,
       cost,
       usage,
@@ -560,7 +560,7 @@ export async function chat(options) {
   } catch (error) {
     const duration = Date.now() - startTime;
 
-    console.error("[llm] Error in chat():", {
+    logger.error("Error in chat():", {
       error: error.message,
       name: error.name,
       stack: error.stack,

package/src/providers/anthropic.js

@@ -7,6 +7,9 @@ import {
   ensureJsonResponseFormat,
   ProviderJsonParseError,
 } from "./base.js";
+import { createLogger } from "../core/logger.js";
+
+const logger = createLogger("Anthropic");
 
 export async function anthropicChat({
   messages,
@@ -18,16 +21,16 @@ export async function anthropicChat({
   stop,
   maxRetries = 3,
 }) {
-  console.log("\n[Anthropic] Starting anthropicChat call");
-  console.log("[Anthropic] Model:", model);
-  console.log("[Anthropic] Response format:", responseFormat);
+  logger.log("\nStarting anthropicChat call");
+  logger.log("Model:", model);
+  logger.log("Response format:", responseFormat);
 
   // Enforce JSON mode - reject calls without proper JSON responseFormat
   ensureJsonResponseFormat(responseFormat, "Anthropic");
 
   const { systemMsg, userMsg } = extractMessages(messages);
-  console.log("[Anthropic] System message length:", systemMsg.length);
-  console.log("[Anthropic] User message length:", userMsg.length);
+  logger.log("System message length:", systemMsg.length);
+  logger.log("User message length:", userMsg.length);
 
   // Build system guard for JSON enforcement
   let system = systemMsg;
@@ -43,7 +46,7 @@ export async function anthropicChat({
     }
 
     try {
-      console.log(`[Anthropic] Attempt ${attempt + 1}/${maxRetries + 1}`);
+      logger.log(`Attempt ${attempt + 1}/${maxRetries + 1}`);
 
       const requestBody = {
         model,
@@ -55,7 +58,7 @@ export async function anthropicChat({
         ...(stop !== undefined ? { stop_sequences: stop } : {}),
       };
 
-      console.log("[Anthropic] Calling Anthropic API...");
+      logger.log("Calling Anthropic API...");
       const response = await fetch("https://api.anthropic.com/v1/messages", {
         method: "POST",
         headers: {
@@ -74,7 +77,7 @@ export async function anthropicChat({
       }
 
       const data = await response.json();
-      console.log("[Anthropic] Response received from Anthropic API");
+      logger.log("Response received from Anthropic API");
 
       // Extract text from response.content blocks
       const blocks = Array.isArray(data?.content) ? data.content : [];
@@ -84,7 +87,7 @@ export async function anthropicChat({
         .join("");
       // Always strip markdown fences first to prevent parse failures
       const text = stripMarkdownFences(rawText);
-      console.log("[Anthropic] Response text length:", text.length);
+      logger.log("Response text length:", text.length);
 
       // Parse JSON - this is required for all calls
       const parsed = tryParseJSON(text);
@@ -106,7 +109,7 @@ export async function anthropicChat({
           ? { prompt_tokens, completion_tokens, total_tokens }
           : undefined;
 
-      console.log("[Anthropic] Returning response from Anthropic API");
+      logger.log("Returning response from Anthropic API");
       return {
         content: parsed,
         text,
@@ -116,13 +119,13 @@ export async function anthropicChat({
     } catch (error) {
       lastError = error;
       const msg = error?.error?.message || error?.message || "";
-      console.error("[Anthropic] Error occurred:", msg);
-      console.error("[Anthropic] Error status:", error?.status);
+      logger.error("Error occurred:", msg);
+      logger.error("Error status:", error?.status);
 
       if (error.status === 401) throw error;
 
       if (isRetryableError(error) && attempt < maxRetries) {
-        console.log("[Anthropic] Retrying due to retryable error");
+        logger.log("Retrying due to retryable error");
         continue;
       }
 

package/src/providers/deepseek.js

@@ -7,6 +7,9 @@ import {
   ensureJsonResponseFormat,
   ProviderJsonParseError,
 } from "./base.js";
+import { createLogger } from "../core/logger.js";
+
+const logger = createLogger("DeepSeek");
 
 export async function deepseekChat({
   messages,
@@ -163,7 +166,7 @@ async function* createStreamGenerator(stream) {
             }
           } catch (e) {
             // Skip malformed JSON
-            console.warn("[deepseek] Failed to parse stream chunk:", e);
+            logger.warn("Failed to parse stream chunk:", e);
           }
         }
       }

package/src/providers/gemini.js

@@ -7,6 +7,9 @@ import {
   ensureJsonResponseFormat,
   ProviderJsonParseError,
 } from "./base.js";
+import { createLogger } from "../core/logger.js";
+
+const logger = createLogger("Gemini");
 
 /**
  * Google Gemini provider implementation
@@ -120,15 +123,13 @@ export async function geminiChat(options) {
     }
 
     try {
-      console.log(
-        `[Gemini] Starting geminiChat call (attempt ${attempt + 1}/${maxRetries + 1})`
-      );
-      console.log(`[Gemini] Model: ${model}`);
-      console.log(`[Gemini] Response format:`, responseFormat);
-      console.log(
-        `[Gemini] System instruction length: ${systemInstruction.length}`
+      logger.log(
+        `Starting geminiChat call (attempt ${attempt + 1}/${maxRetries + 1})`
       );
-      console.log(`[Gemini] User message length: ${userMsg.length}`);
+      logger.log(`Model: ${model}`);
+      logger.log(`Response format:`, responseFormat);
+      logger.log(`System instruction length: ${systemInstruction.length}`);
+      logger.log(`User message length: ${userMsg.length}`);
 
       const response = await fetch(url, {
         method: "POST",
@@ -153,7 +154,7 @@ export async function geminiChat(options) {
 
         // Retry on retryable errors
         if (isRetryableError(error) && attempt < maxRetries) {
-          console.log(`[Gemini] Retryable error, retrying...`);
+          logger.log(`Retryable error, retrying...`);
           lastError = error;
           continue;
         }
@@ -162,8 +163,8 @@ export async function geminiChat(options) {
       }
 
       const data = await response.json();
-      console.log(
-        `[Gemini] Response received, candidates length: ${data.candidates?.length || 0}`
+      logger.log(
+        `Response received, candidates length: ${data.candidates?.length || 0}`
       );
 
       // Extract text from response
@@ -175,7 +176,7 @@ export async function geminiChat(options) {
       const rawText = candidate.content.parts[0].text;
       // Always strip markdown fences first to prevent parse failures
       const text = stripMarkdownFences(rawText);
-      console.log(`[Gemini] Text length: ${text.length}`);
+      logger.log(`Text length: ${text.length}`);
 
       // Parse JSON if required
       const parsed = tryParseJSON(text);
@@ -197,7 +198,7 @@ export async function geminiChat(options) {
           }
         : undefined;
 
-      console.log(`[Gemini] Usage:`, usage);
+      logger.log(`Usage:`, usage);
 
       return {
         content: parsed || text,
@@ -206,8 +207,8 @@ export async function geminiChat(options) {
         raw: data,
       };
     } catch (error) {
-      console.error(`[Gemini] Error occurred: ${error.message}`);
-      console.error(`[Gemini] Error status: ${error.status}`);
+      logger.error(`Error occurred: ${error.message}`);
+      logger.error(`Error status: ${error.status}`);
 
       lastError = error;
 

package/src/providers/openai.js

@@ -8,6 +8,9 @@ import {
   ensureJsonResponseFormat,
   ProviderJsonParseError,
 } from "./base.js";
+import { createLogger } from "../core/logger.js";
+
+const logger = createLogger("OpenAI");
 
 let client = null;
 
@@ -43,16 +46,16 @@ export async function openaiChat({
   maxRetries = 3,
   ...rest
 }) {
-  console.log("\n[OpenAI] Starting openaiChat call");
-  console.log("[OpenAI] Model:", model);
-  console.log("[OpenAI] Response format:", responseFormat);
+  logger.log("\nStarting openaiChat call");
+  logger.log("Model:", model);
+  logger.log("Response format:", responseFormat);
 
   const openai = getClient();
   if (!openai) throw new Error("OpenAI API key not configured");
 
   const { systemMsg, userMsg } = extractMessages(messages);
-  console.log("[OpenAI] System message length:", systemMsg.length);
-  console.log("[OpenAI] User message length:", userMsg.length);
+  logger.log("System message length:", systemMsg.length);
+  logger.log("User message length:", userMsg.length);
 
   // Determine if JSON mode is requested (handle both object and string formats)
   const isJsonMode =
@@ -68,11 +71,11 @@ export async function openaiChat({
     const useResponsesAPI = /^gpt-5/i.test(model);
 
     try {
-      console.log(`[OpenAI] Attempt ${attempt + 1}/${maxRetries + 1}`);
+      logger.log(`Attempt ${attempt + 1}/${maxRetries + 1}`);
 
       // ---------- RESPONSES API path (GPT-5 models) ----------
       if (useResponsesAPI) {
-        console.log("[OpenAI] Using Responses API for GPT-5 model");
+        logger.log("Using Responses API for GPT-5 model");
         const responsesReq = {
           model,
           instructions: systemMsg,
@@ -100,12 +103,12 @@ export async function openaiChat({
           responsesReq.text = { format: { type: "json_object" } };
         }
 
-        console.log("[OpenAI] Calling responses.create...");
+        logger.log("Calling responses.create...");
         const resp = await openai.responses.create(responsesReq);
         const rawText = resp.output_text ?? "";
         // Always strip markdown fences first to prevent parse failures
         const text = stripMarkdownFences(rawText);
-        console.log("[OpenAI] Response received, text length:", text.length);
+        logger.log("Response received, text length:", text.length);
 
         // Approximate usage (tests don't assert exact values)
         const promptTokens = Math.ceil((systemMsg + userMsg).length / 4);
@@ -127,20 +130,16 @@ export async function openaiChat({
               "Failed to parse JSON response from Responses API"
             );
           }
-          console.log(
-            "[OpenAI] Returning response from Responses API (JSON mode)"
-          );
+          logger.log("Returning response from Responses API (JSON mode)");
           return { content: parsed, text, usage, raw: resp };
         }
 
-        console.log(
-          "[OpenAI] Returning response from Responses API (text mode)"
-        );
+        logger.log("Returning response from Responses API (text mode)");
         return { content: text, text, usage, raw: resp };
       }
 
       // ---------- CLASSIC CHAT COMPLETIONS path (non-GPT-5) ----------
-      console.log("[OpenAI] Using Classic Chat Completions API");
+      logger.log("Using Classic Chat Completions API");
       const classicReq = {
         model,
         messages,
@@ -163,15 +162,12 @@ export async function openaiChat({
         classicReq.response_format = { type: "json_object" };
       }
 
-      console.log("[OpenAI] Calling chat.completions.create...");
+      logger.log("Calling chat.completions.create...");
       const classicRes = await openai.chat.completions.create(classicReq);
       const rawClassicText = classicRes?.choices?.[0]?.message?.content ?? "";
       // Always strip markdown fences first to prevent parse failures
       const classicText = stripMarkdownFences(rawClassicText);
-      console.log(
-        "[OpenAI] Response received, text length:",
-        classicText.length
-      );
+      logger.log("Response received, text length:", classicText.length);
 
       // Parse JSON only in JSON mode; return raw string for text mode
       if (isJsonMode) {
@@ -201,16 +197,16 @@ export async function openaiChat({
     } catch (error) {
       lastError = error;
       const msg = error?.error?.message || error?.message || "";
-      console.error("[OpenAI] Error occurred:", msg);
-      console.error("[OpenAI] Error status:", error?.status);
+      logger.error("Error occurred:", msg);
+      logger.error("Error status:", error?.status);
 
       // Only fall back when RESPONSES path failed due to lack of support
       if (
         useResponsesAPI &&
         (/not supported/i.test(msg) || /unsupported/i.test(msg))
       ) {
-        console.log(
-          "[OpenAI] Falling back to Classic API due to unsupported Responses API"
+        logger.log(
+          "Falling back to Classic API due to unsupported Responses API"
         );
         const classicReq = {
           model,

package/src/providers/zhipu.js

@@ -7,6 +7,9 @@ import {
   ensureJsonResponseFormat,
   ProviderJsonParseError,
 } from "./base.js";
+import { createLogger } from "../core/logger.js";
+
+const logger = createLogger("Zhipu");
 
 export async function zhipuChat({
   messages,
@@ -18,9 +21,9 @@ export async function zhipuChat({
   stop,
   maxRetries = 3,
 }) {
-  console.log("\n[Zhipu] Starting zhipuChat call");
-  console.log("[Zhipu] Model:", model);
-  console.log("[Zhipu] Response format:", responseFormat);
+  logger.log("\nStarting zhipuChat call");
+  logger.log("Model:", model);
+  logger.log("Response format:", responseFormat);
 
   // Enforce JSON mode - reject calls without proper JSON responseFormat
   ensureJsonResponseFormat(responseFormat, "Zhipu");
@@ -30,8 +33,8 @@ export async function zhipuChat({
   }
 
   const { systemMsg, userMsg } = extractMessages(messages);
-  console.log("[Zhipu] System message length:", systemMsg.length);
-  console.log("[Zhipu] User message length:", userMsg.length);
+  logger.log("System message length:", systemMsg.length);
+  logger.log("User message length:", userMsg.length);
 
   // Build system guard for JSON enforcement
   let system = systemMsg;
@@ -51,7 +54,7 @@ export async function zhipuChat({
     }
 
     try {
-      console.log(`[Zhipu] Attempt ${attempt + 1}/${maxRetries + 1}`);
+      logger.log(`Attempt ${attempt + 1}/${maxRetries + 1}`);
 
       const requestBody = {
         model,
@@ -65,7 +68,7 @@ export async function zhipuChat({
         ...(stop !== undefined ? { stop: stop } : {}),
       };
 
-      console.log("[Zhipu] Calling Zhipu API...");
+      logger.log("Calling Zhipu API...");
       const response = await fetch(
         "https://api.z.ai/api/paas/v4/chat/completions",
         {
@@ -102,13 +105,13 @@ export async function zhipuChat({
       }
 
       const data = await response.json();
-      console.log("[Zhipu] Response received from Zhipu API");
+      logger.log("Response received from Zhipu API");
 
       // Extract text from response
       const rawText = data?.choices?.[0]?.message?.content || "";
       // Always strip markdown fences first to prevent parse failures
       const text = stripMarkdownFences(rawText);
-      console.log("[Zhipu] Response text length:", text.length);
+      logger.log("Response text length:", text.length);
 
       // Parse JSON - this is required for all calls
       const parsed = tryParseJSON(text);
@@ -130,7 +133,7 @@ export async function zhipuChat({
           ? { prompt_tokens, completion_tokens, total_tokens }
           : undefined;
 
-      console.log("[Zhipu] Returning response from Zhipu API");
+      logger.log("Returning response from Zhipu API");
       return {
         content: parsed,
         text,
@@ -140,13 +143,13 @@ export async function zhipuChat({
     } catch (error) {
       lastError = error;
       const msg = error?.message || error?.toString() || "Unknown error";
-      console.error("[Zhipu] Error occurred:", msg);
-      console.error("[Zhipu] Error status:", error?.status);
+      logger.error("Error occurred:", msg);
+      logger.error("Error status:", error?.status);
 
       if (error.status === 401) throw error;
 
       if (isRetryableError(error) && attempt < maxRetries) {
-        console.log("[Zhipu] Retrying due to retryable error");
+        logger.log("Retrying due to retryable error");
         continue;
       }