@ryanfw/prompt-orchestration-pipeline 0.0.1 → 0.4.0

package/src/llm/index.js

@@ -2,6 +2,7 @@ import { openaiChat } from "../providers/openai.js";
 import { deepseekChat } from "../providers/deepseek.js";
 import { EventEmitter } from "node:events";
 import { getConfig } from "../core/config.js";
+import fs from "node:fs";
 
 // Global mock provider instance (for demo/testing)
 let mockProviderInstance = null;
@@ -15,6 +16,24 @@ export function registerMockProvider(provider) {
   mockProviderInstance = provider;
 }
 
+// Auto-register mock provider in test mode when default provider is "mock"
+function autoRegisterMockProvider() {
+  const config = getConfig();
+  if (config.llm.defaultProvider === "mock" && !mockProviderInstance) {
+    // Auto-register a basic mock provider for testing
+    mockProviderInstance = {
+      chat: async () => ({
+        content: "Mock response for testing",
+        usage: {
+          prompt_tokens: 100,
+          completion_tokens: 200,
+          total_tokens: 300,
+        },
+      }),
+    };
+  }
+}
+
 // Check available providers
 export function getAvailableProviders() {
   return {
@@ -64,10 +83,10 @@ export function calculateCost(provider, model, usage) {
   return promptCost + completionCost;
 }
 
-// Main chat function - no metrics handling needed!
+// Core chat function - no metrics handling needed!
 export async function chat(options) {
   const {
-    provider = "openai",
+    provider,
     model,
     messages = [],
     temperature,
@@ -76,6 +95,9 @@ export async function chat(options) {
     ...rest
   } = options;
 
+  // Auto-register mock provider if needed
+  autoRegisterMockProvider();
+
   const available = getAvailableProviders();
 
   if (!available[provider]) {
@@ -90,6 +112,12 @@ export async function chat(options) {
   const userMessages = messages.filter((m) => m.role === "user");
   const userMsg = userMessages.map((m) => m.content).join("\n");
 
+  // DEBUG write the messages to /tmp/messages.log for debugging
+  fs.writeFileSync(
+    "/tmp/messages.log",
+    JSON.stringify({ messages, systemMsg, userMsg, provider, model }, null, 2)
+  );
+
   // Emit request start event
   llmEvents.emit("llm:request:start", {
     id: requestId,
@@ -152,18 +180,24 @@ export async function chat(options) {
       };
     } else if (provider === "deepseek") {
       const result = await deepseekChat(
-        systemMsg,
-        userMsg,
-        model || "deepseek-reasoner"
+        {
+          messages,
+          model: "deepseek-chat",
+        }
+
+        // systemMsg,
+        // userMsg,
+        // model || "deepseek-reasoner"
       );
 
       response = {
-        content: typeof result === "string" ? result : JSON.stringify(result),
-        raw: result,
+        content: result.content,
       };
 
       const promptTokens = estimateTokens(systemMsg + userMsg);
-      const completionTokens = estimateTokens(response.content);
+      const completionTokens = estimateTokens(
+        typeof result === "string" ? result : JSON.stringify(result)
+      );
       usage = {
         promptTokens,
         completionTokens,
@@ -189,10 +223,7 @@ export async function chat(options) {
     });
 
     // Return clean response - no metrics attached!
-    return {
-      ...response,
-      usage,
-    };
+    return response;
   } catch (error) {
     const duration = Date.now() - startTime;
 
@@ -211,110 +242,229 @@ export async function chat(options) {
   }
 }
 
-// Convenience function for simple completions
+// Helper to convert model alias to camelCase function name
+function toCamelCase(alias) {
+  const [provider, ...modelParts] = alias.split(":");
+  const model = modelParts.join("-");
+
+  // Convert to camelCase (handle both letters and numbers after hyphens)
+  const camelModel = model.replace(/-([a-z0-9])/g, (match, char) =>
+    char.toUpperCase()
+  );
+
+  return camelModel;
+}
+
+// Build provider-grouped functions from registry
+function buildProviderFunctions(models) {
+  const functions = {};
+
+  // Group by provider
+  const byProvider = {};
+  for (const [alias, config] of Object.entries(models)) {
+    const { provider } = config;
+    if (!byProvider[provider]) {
+      byProvider[provider] = {};
+    }
+    byProvider[provider][alias] = config;
+  }
+
+  // Create functions for each provider
+  for (const [provider, providerModels] of Object.entries(byProvider)) {
+    functions[provider] = {};
+
+    for (const [alias, modelConfig] of Object.entries(providerModels)) {
+      const functionName = toCamelCase(alias);
+
+      functions[provider][functionName] = (options = {}) => {
+        // Respect provider overrides in options (last-write-wins)
+        const finalProvider = options.provider || provider;
+        const finalModel = options.model || modelConfig.model;
+
+        return chat({
+          provider: finalProvider,
+          model: finalModel,
+          ...options,
+          metadata: {
+            ...options.metadata,
+            alias,
+          },
+        });
+      };
+    }
+  }
+
+  return functions;
+}
+
+// Helper function for single prompt completion
 export async function complete(prompt, options = {}) {
+  const config = getConfig();
+  const defaultProvider = options.provider || config.llm.defaultProvider;
+
   return chat({
-    ...options,
+    provider: defaultProvider,
     messages: [{ role: "user", content: prompt }],
+    ...options,
   });
 }
 
-// Create a chain for multi-turn conversations
+// Chain implementation
 export function createChain() {
-  const messages = [];
+  let messages = [];
 
   return {
-    addSystemMessage: function (content) {
+    addSystemMessage(content) {
       messages.push({ role: "system", content });
-      return this;
     },
-
-    addUserMessage: function (content) {
+    addUserMessage(content) {
       messages.push({ role: "user", content });
-      return this;
     },
-
-    addAssistantMessage: function (content) {
+    addAssistantMessage(content) {
       messages.push({ role: "assistant", content });
-      return this;
     },
-
-    execute: async function (options = {}) {
-      const response = await chat({ ...options, messages });
-      messages.push({
-        role: "assistant",
-        content: response.content,
-      });
-      return response;
+    getMessages() {
+      return [...messages]; // Return copy to prevent external mutation
     },
-
-    getMessages: () => [...messages],
-
-    clear: function () {
-      messages.length = 0;
-      return this;
+    clear() {
+      messages = [];
+    },
+    async execute(options = {}) {
+      const result = await chat({
+        messages: [...messages],
+        ...options,
+      });
+      messages.push({ role: "assistant", content: result.content });
+      return result;
     },
   };
 }
 
-// Retry wrapper
-export async function withRetry(fn, args = [], options = {}) {
-  const config = getConfig();
-  const maxRetries = options.maxRetries ?? config.llm.retryMaxAttempts;
-  const backoffMs = options.backoffMs ?? config.llm.retryBackoffMs;
-
+// Retry implementation with exponential backoff
+export async function withRetry(
+  fn,
+  args = [],
+  { maxRetries = 3, backoffMs = 100 } = {}
+) {
   let lastError;
 
-  for (let i = 0; i <= maxRetries; i++) {
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
     try {
-      if (i > 0) {
-        await new Promise((r) => setTimeout(r, backoffMs * Math.pow(2, i - 1)));
-      }
       return await fn(...args);
     } catch (error) {
       lastError = error;
-      // Don't retry auth errors
-      if (error.status === 401 || error.message?.includes("API key")) {
+
+      // Don't retry on auth errors
+      if (error.status === 401) {
         throw error;
       }
+
+      // If this is the last attempt, throw the error
+      if (attempt === maxRetries) {
+        throw error;
+      }
+
+      // Wait with exponential backoff
+      const delay = backoffMs * Math.pow(2, attempt);
+      await new Promise((resolve) => setTimeout(resolve, delay));
     }
   }
 
   throw lastError;
 }
 
-// Parallel execution with concurrency control
-export async function parallel(fn, items, maxConcurrency) {
-  const config = getConfig();
-  const concurrency = maxConcurrency ?? config.llm.maxConcurrency;
+// Parallel execution with concurrency limit
+export async function parallel(workerFn, items, concurrency = 5) {
+  if (!items || items.length === 0) {
+    return [];
+  }
+
+  const results = new Array(items.length);
+  const executing = [];
+
+  for (let i = 0; i < items.length; i++) {
+    const promise = workerFn(items[i]).then((result) => {
+      results[i] = result;
+    });
+
+    executing.push(promise);
 
-  const results = [];
-  for (let i = 0; i < items.length; i += concurrency) {
-    const batch = items.slice(i, i + concurrency);
-    const batchResults = await Promise.all(batch.map((item) => fn(item)));
-    results.push(...batchResults);
+    if (executing.length >= concurrency) {
+      await Promise.race(executing);
+      // Remove completed promises from executing array
+      executing.splice(
+        executing.findIndex((p) => p === promise),
+        1
+      );
+    }
   }
+
+  // Wait for all remaining promises
+  await Promise.all(executing);
+
   return results;
 }
 
-// Create a bound LLM interface (no metrics handling needed!)
-export function createLLM(options = {}) {
+// Create a bound LLM interface - for named-models tests, only return provider functions
+export function createLLM() {
+  const config = getConfig();
+
+  // Build functions from registry
+  const providerFunctions = buildProviderFunctions(config.llm.models);
+
+  return providerFunctions;
+}
+
+// Separate function for high-level LLM interface (used by llm.test.js)
+export function createHighLevelLLM(options = {}) {
   const config = getConfig();
   const defaultProvider = options.defaultProvider || config.llm.defaultProvider;
 
+  // Build functions from registry
+  const providerFunctions = buildProviderFunctions(config.llm.models);
+
   return {
-    chat: (opts) => chat({ provider: defaultProvider, ...opts }),
-    complete: (prompt, opts) =>
-      complete(prompt, { provider: defaultProvider, ...opts }),
-    createChain: () => createChain(),
-    withRetry: (opts) =>
-      withRetry(chat, [{ provider: defaultProvider, ...opts }]),
-    parallel: (requests, maxConcurrency) =>
-      parallel(
-        (req) => chat({ provider: defaultProvider, ...req }),
+    // High-level interface methods
+    chat(opts = {}) {
+      return chat({
+        provider: defaultProvider,
+        ...opts,
+      });
+    },
+
+    complete(prompt, opts = {}) {
+      return complete(prompt, {
+        provider: defaultProvider,
+        ...opts,
+      });
+    },
+
+    createChain,
+
+    withRetry(opts = {}) {
+      return withRetry(() =>
+        chat({
+          provider: defaultProvider,
+          ...opts,
+        })
+      );
+    },
+
+    async parallel(requests, concurrency = 5) {
+      return parallel(
+        (request) =>
+          chat({
+            provider: defaultProvider,
+            ...request,
+          }),
         requests,
-        maxConcurrency
-      ),
+        concurrency
+      );
+    },
+
     getAvailableProviders,
+
+    // Include provider-grouped functions for backward compatibility
+    ...providerFunctions,
   };
 }

package/src/pages/PipelineDetail.jsx

@@ -0,0 +1,111 @@
+import React from "react";
+import { useParams } from "react-router-dom";
+import { Box, Flex, Text } from "@radix-ui/themes";
+import JobDetail from "../components/JobDetail.jsx";
+import { useJobDetailWithUpdates } from "../ui/client/hooks/useJobDetailWithUpdates.js";
+import Layout from "../components/Layout.jsx";
+import { statusBadge } from "../utils/ui.jsx";
+
+export default function PipelineDetail() {
+  const { jobId } = useParams();
+
+  // Handle missing job ID (undefined/null)
+  if (jobId === undefined || jobId === null) {
+    return (
+      <Layout title="Pipeline Details" showBackButton={true}>
+        <Flex align="center" justify="center" className="min-h-64">
+          <Box className="text-center">
+            <Text size="5" weight="medium" color="red" className="mb-2">
+              No job ID provided
+            </Text>
+          </Box>
+        </Flex>
+      </Layout>
+    );
+  }
+
+  const { data: job, loading, error } = useJobDetailWithUpdates(jobId);
+
+  if (loading) {
+    return (
+      <Layout title="Pipeline Details" showBackButton={true}>
+        <Flex align="center" justify="center" className="min-h-64">
+          <Box className="text-center">
+            <Text size="5" weight="medium" className="mb-2">
+              Loading job details...
+            </Text>
+          </Box>
+        </Flex>
+      </Layout>
+    );
+  }
+
+  if (error) {
+    return (
+      <Layout title="Pipeline Details" showBackButton={true}>
+        <Flex align="center" justify="center" className="min-h-64">
+          <Box className="text-center">
+            <Text size="5" weight="medium" color="red" className="mb-2">
+              Failed to load job details
+            </Text>
+            <Text size="2" color="gray" className="mt-2">
+              {error}
+            </Text>
+          </Box>
+        </Flex>
+      </Layout>
+    );
+  }
+
+  if (!job) {
+    return (
+      <Layout title="Pipeline Details" showBackButton={true}>
+        <Flex align="center" justify="center" className="min-h-64">
+          <Box className="text-center">
+            <Text size="5" weight="medium" className="mb-2">
+              Job not found
+            </Text>
+          </Box>
+        </Flex>
+      </Layout>
+    );
+  }
+
+  // Derive pipeline if not provided in job data
+  const pipeline =
+    job?.pipeline ||
+    (() => {
+      if (!job?.tasks) return { tasks: [] };
+
+      let pipelineTasks = [];
+      if (Array.isArray(job.tasks)) {
+        // tasks is an array, extract names
+        pipelineTasks = job.tasks.map((task) => task.name);
+      } else if (job.tasks && typeof job.tasks === "object") {
+        // tasks is an object, extract keys
+        pipelineTasks = Object.keys(job.tasks);
+      }
+
+      return { tasks: pipelineTasks };
+    })();
+
+  // Header actions: job ID and status badge
+  const headerActions = (
+    <Flex align="center" gap="3" className="shrink-0">
+      <Text size="2" color="gray">
+        ID: {job.id || jobId}
+      </Text>
+      {statusBadge(job.status)}
+    </Flex>
+  );
+
+  return (
+    <Layout
+      title={job.name || "Pipeline Details"}
+      showBackButton={true}
+      actions={headerActions}
+    >
+      <JobDetail job={job} pipeline={pipeline} />
+    </Layout>
+  );
+}