@ryanfw/prompt-orchestration-pipeline 0.5.0 → 0.7.0

package/src/pages/PromptPipelineDashboard.jsx

@@ -1,18 +1,16 @@
 // PromptPipelineDashboard.jsx
-import React, { useEffect, useMemo, useState } from "react";
+import React, { useMemo, useState } from "react";
 import { useNavigate } from "react-router-dom";
 
-import { Box, Flex, Text, Heading, Tabs, Card } from "@radix-ui/themes";
+import { Box, Flex, Text, Tabs } from "@radix-ui/themes";
 
 import { Progress } from "../components/ui/progress";
 import { useJobListWithUpdates } from "../ui/client/hooks/useJobListWithUpdates";
 import { adaptJobSummary } from "../ui/client/adapters/job-adapter";
-import { jobCumulativeDurationMs } from "../utils/duration";
-import { useTicker } from "../ui/client/hooks/useTicker";
+import { TaskState, JobStatus } from "../config/statuses.js";
 
 // Referenced components — leave these alone
 import JobTable from "../components/JobTable";
-import UploadSeed from "../components/UploadSeed";
 import Layout from "../components/Layout.jsx";
 
 export default function PromptPipelineDashboard({ isConnected }) {
@@ -55,43 +53,40 @@ export default function PromptPipelineDashboard({ isConnected }) {
     return src.map(adaptJobSummary);
   }, [apiJobs, error]);
   const [activeTab, setActiveTab] = useState("current");
-  const [seedUploadSuccess, setSeedUploadSuccess] = useState(null);
-  const [seedUploadTimer, setSeedUploadTimer] = useState(null);
 
-  // Shared ticker for live duration updates
-  const now = useTicker(10000);
+  // Shared ticker for live duration updates - removed useTicker
 
   const errorCount = useMemo(
-    () => jobs.filter((j) => j.status === "failed").length,
+    () => jobs.filter((j) => j.status === TaskState.FAILED).length,
     [jobs]
   );
   const currentCount = useMemo(
-    () => jobs.filter((j) => j.status === "running").length,
+    () => jobs.filter((j) => j.status === TaskState.RUNNING).length,
     [jobs]
   );
   const completedCount = useMemo(
-    () => jobs.filter((j) => j.status === "complete").length,
+    () => jobs.filter((j) => j.status === JobStatus.COMPLETE).length,
     [jobs]
   );
 
   const filteredJobs = useMemo(() => {
     switch (activeTab) {
       case "current":
-        return jobs.filter((j) => j.status === "running");
+        return jobs.filter((j) => j.status === TaskState.RUNNING);
       case "errors":
-        return jobs.filter((j) => j.status === "failed");
+        return jobs.filter((j) => j.status === TaskState.FAILED);
       case "complete":
-        return jobs.filter((j) => j.status === "complete");
+        return jobs.filter((j) => j.status === JobStatus.COMPLETE);
       default:
         return [];
     }
   }, [jobs, activeTab]);
 
-  const overallElapsed = (job) => jobCumulativeDurationMs(job, now);
+  // overallElapsed function removed - JobTable now uses LiveText for duration calculations
 
   // Aggregate progress for currently running jobs (for a subtle top progress bar)
   const runningJobs = useMemo(
-    () => jobs.filter((j) => j.status === "running"),
+    () => jobs.filter((j) => j.status === TaskState.RUNNING),
     [jobs]
   );
   const aggregateProgress = useMemo(() => {
@@ -111,34 +106,6 @@ export default function PromptPipelineDashboard({ isConnected }) {
     }
   };
 
-  // Handle seed upload success
-  const handleSeedUploadSuccess = ({ jobName }) => {
-    // Clear any existing timer
-    if (seedUploadTimer) {
-      clearTimeout(seedUploadTimer);
-    }
-
-    // Set success message
-    setSeedUploadSuccess(jobName);
-
-    // Auto-clear after exactly 5000 ms
-    const timer = setTimeout(() => {
-      setSeedUploadSuccess(null);
-      setSeedUploadTimer(null);
-    }, 5000);
-
-    setSeedUploadTimer(timer);
-  };
-
-  // Cleanup timer on unmount
-  useEffect(() => {
-    return () => {
-      if (seedUploadTimer) {
-        clearTimeout(seedUploadTimer);
-      }
-    };
-  }, [seedUploadTimer]);
-
   // Header actions for Layout
   const headerActions = runningJobs.length > 0 && (
     <Flex align="center" gap="2" className="text-gray-11">
@@ -154,26 +121,6 @@ export default function PromptPipelineDashboard({ isConnected }) {
 
   return (
     <Layout title="Prompt Pipeline" actions={headerActions}>
-      {/* Upload Seed File Section */}
-      <Card className="mb-6">
-        <Flex direction="column" gap="3">
-          <Heading size="4" weight="medium" className="text-gray-12">
-            Upload Seed File
-          </Heading>
-
-          {/* Success Message */}
-          {seedUploadSuccess && (
-            <Box className="rounded-md bg-green-50 p-3 border border-green-200">
-              <Text size="2" className="text-green-800">
-                Job <strong>{seedUploadSuccess}</strong> created successfully
-              </Text>
-            </Box>
-          )}
-
-          <UploadSeed onUploadSuccess={handleSeedUploadSuccess} />
-        </Flex>
-      </Card>
-
       {error && (
         <Box className="mb-4 rounded-md bg-yellow-50 p-3 border border-yellow-200">
           <Text size="2" className="text-yellow-800">
@@ -181,7 +128,11 @@ export default function PromptPipelineDashboard({ isConnected }) {
           </Text>
         </Box>
       )}
-      <Tabs.Root value={activeTab} onValueChange={setActiveTab}>
+      <Tabs.Root
+        value={activeTab}
+        onValueChange={setActiveTab}
+        className="mt-4"
+      >
         <Tabs.List aria-label="Job filters">
           <Tabs.Trigger value="current">Current ({currentCount})</Tabs.Trigger>
           <Tabs.Trigger value="errors">Errors ({errorCount})</Tabs.Trigger>
@@ -189,33 +140,14 @@ export default function PromptPipelineDashboard({ isConnected }) {
             Completed ({completedCount})
           </Tabs.Trigger>
         </Tabs.List>
-
         <Tabs.Content value="current">
-          <JobTable
-            jobs={filteredJobs}
-            pipeline={null}
-            onOpenJob={openJob}
-            overallElapsed={overallElapsed}
-            now={now}
-          />
+          <JobTable jobs={filteredJobs} pipeline={null} onOpenJob={openJob} />
         </Tabs.Content>
         <Tabs.Content value="errors">
-          <JobTable
-            jobs={filteredJobs}
-            pipeline={null}
-            onOpenJob={openJob}
-            overallElapsed={overallElapsed}
-            now={now}
-          />
+          <JobTable jobs={filteredJobs} pipeline={null} onOpenJob={openJob} />
         </Tabs.Content>
         <Tabs.Content value="complete">
-          <JobTable
-            jobs={filteredJobs}
-            pipeline={null}
-            onOpenJob={openJob}
-            overallElapsed={overallElapsed}
-            now={now}
-          />
+          <JobTable jobs={filteredJobs} pipeline={null} onOpenJob={openJob} />
         </Tabs.Content>
       </Tabs.Root>
     </Layout>

package/src/providers/anthropic.js

@@ -1,54 +1,38 @@
-import Anthropic from "@anthropic-ai/sdk";
 import {
   extractMessages,
   isRetryableError,
   sleep,
   tryParseJSON,
+  ensureJsonResponseFormat,
+  ProviderJsonParseError,
 } from "./base.js";
 
-let client = null;
-
-function getClient() {
-  if (!client && process.env.ANTHROPIC_API_KEY) {
-    client = new Anthropic({
-      apiKey: process.env.ANTHROPIC_API_KEY,
-      baseURL: process.env.ANTHROPIC_BASE_URL,
-    });
-  }
-  return client;
-}
-
 export async function anthropicChat({
   messages,
-  model = "claude-3-opus-20240229",
+  model = "claude-3-sonnet",
   temperature = 0.7,
-  maxTokens = 4096,
-  responseFormat,
+  maxTokens = 8192,
+  responseFormat = "json",
   topP,
-  topK,
-  stopSequences,
+  stop,
   maxRetries = 3,
 }) {
-  const anthropic = getClient();
-  if (!anthropic) throw new Error("Anthropic API key not configured");
-
-  const { systemMsg, userMessages, assistantMessages } =
-    extractMessages(messages);
-
-  // Convert messages to Anthropic format
-  const anthropicMessages = [];
-  for (const msg of messages) {
-    if (msg.role === "user" || msg.role === "assistant") {
-      anthropicMessages.push({
-        role: msg.role,
-        content: msg.content,
-      });
-    }
-  }
+  console.log("\n[Anthropic] Starting anthropicChat call");
+  console.log("[Anthropic] Model:", model);
+  console.log("[Anthropic] 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);
+
+  // Build system guard for JSON enforcement
+  let system = systemMsg;
 
-  // Ensure messages alternate and start with user
-  if (anthropicMessages.length === 0 || anthropicMessages[0].role !== "user") {
-    anthropicMessages.unshift({ role: "user", content: "Hello" });
+  if (responseFormat === "json" || responseFormat?.type === "json_object") {
+    system = `${systemMsg}\n\nYou must output strict JSON only with no extra text.`;
   }
 
   let lastError;
@@ -58,54 +42,84 @@ export async function anthropicChat({
     }
 
     try {
-      const request = {
+      console.log(`[Anthropic] Attempt ${attempt + 1}/${maxRetries + 1}`);
+
+      const requestBody = {
         model,
-        messages: anthropicMessages,
-        max_tokens: maxTokens,
+        system,
+        messages: [{ role: "user", content: userMsg }],
         temperature,
-        top_p: topP,
-        top_k: topK,
-        stop_sequences: stopSequences,
+        max_tokens: maxTokens,
+        ...(topP !== undefined ? { top_p: topP } : {}),
+        ...(stop !== undefined ? { stop_sequences: stop } : {}),
       };
 
-      // Add system message if present
-      if (systemMsg) {
-        request.system = systemMsg;
-      }
-
-      const result = await anthropic.messages.create(request);
+      console.log("[Anthropic] Calling Anthropic API...");
+      const response = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": process.env.ANTHROPIC_API_KEY,
+          "anthropic-version": "2023-06-01",
+        },
+        body: JSON.stringify(requestBody),
+      });
 
-      // Extract text content
-      const content = result.content[0].text;
+      if (!response.ok) {
+        const error = await response
+          .json()
+          .catch(() => ({ error: response.statusText }));
+        throw { status: response.status, ...error };
+      }
 
-      // Try to parse JSON if expected
-      let parsed = null;
-      if (responseFormat?.type === "json_object" || responseFormat === "json") {
-        parsed = tryParseJSON(content);
-        if (!parsed && attempt < maxRetries) {
-          lastError = new Error("Failed to parse JSON response");
-          continue;
-        }
+      const data = await response.json();
+      console.log("[Anthropic] Response received from Anthropic API");
+
+      // Extract text from response.content blocks
+      const blocks = Array.isArray(data?.content) ? data.content : [];
+      const text = blocks
+        .filter((b) => b?.type === "text" && typeof b.text === "string")
+        .map((b) => b.text)
+        .join("");
+      console.log("[Anthropic] Response text length:", text.length);
+
+      // Parse JSON - this is required for all calls
+      const parsed = tryParseJSON(text);
+      if (!parsed) {
+        throw new ProviderJsonParseError(
+          "Anthropic",
+          model,
+          text.substring(0, 200),
+          "Failed to parse JSON response from Anthropic API"
+        );
       }
 
+      // Normalize usage (if provided)
+      const prompt_tokens = data?.usage?.input_tokens;
+      const completion_tokens = data?.usage?.output_tokens;
+      const total_tokens = (prompt_tokens ?? 0) + (completion_tokens ?? 0);
+      const usage =
+        prompt_tokens != null && completion_tokens != null
+          ? { prompt_tokens, completion_tokens, total_tokens }
+          : undefined;
+
+      console.log("[Anthropic] Returning response from Anthropic API");
       return {
-        content: parsed || content,
-        text: content,
-        usage: {
-          prompt_tokens: result.usage.input_tokens,
-          completion_tokens: result.usage.output_tokens,
-          total_tokens: result.usage.input_tokens + result.usage.output_tokens,
-          cache_read_input_tokens: result.usage.cache_creation_input_tokens,
-          cache_write_input_tokens: result.usage.cache_write_input_tokens,
-        },
-        raw: result,
+        content: parsed,
+        text,
+        ...(usage ? { usage } : {}),
+        raw: data,
       };
     } catch (error) {
       lastError = error;
+      const msg = error?.error?.message || error?.message || "";
+      console.error("[Anthropic] Error occurred:", msg);
+      console.error("[Anthropic] Error status:", error?.status);
 
       if (error.status === 401) throw error;
 
       if (isRetryableError(error) && attempt < maxRetries) {
+        console.log("[Anthropic] Retrying due to retryable error");
         continue;
       }
 

package/src/providers/base.js

@@ -69,3 +69,55 @@ export function tryParseJSON(text) {
     }
   }
 }
+
+/**
+ * Error thrown when JSON response format is required but not provided
+ */
+export class ProviderJsonModeError extends Error {
+  constructor(providerName, message) {
+    super(message);
+    this.name = "ProviderJsonModeError";
+    this.provider = providerName;
+  }
+}
+
+/**
+ * Error thrown when JSON parsing fails and should not be retried
+ */
+export class ProviderJsonParseError extends Error {
+  constructor(provider, model, sample, message = "Failed to parse JSON response") {
+    super(message);
+    this.name = "ProviderJsonParseError";
+    this.provider = provider;
+    this.model = model;
+    this.sample = sample;
+  }
+}
+
+/**
+ * Ensures that responseFormat is configured for JSON output
+ * @param {*} responseFormat - The response format object or string
+ * @param {string} providerName - Name of the provider for error reporting
+ * @throws {ProviderJsonModeError} When JSON format is not properly configured
+ */
+export function ensureJsonResponseFormat(responseFormat, providerName) {
+  if (!responseFormat) {
+    throw new ProviderJsonModeError(
+      providerName,
+      `${providerName} requires responseFormat to be set for JSON mode`
+    );
+  }
+
+  // Check for valid JSON format types
+  const isValidJsonFormat = 
+    responseFormat === "json" ||
+    responseFormat?.type === "json_object" ||
+    responseFormat?.type === "json_schema";
+
+  if (!isValidJsonFormat) {
+    throw new ProviderJsonModeError(
+      providerName,
+      `${providerName} only supports JSON response format. Got: ${JSON.stringify(responseFormat)}`
+    );
+  }
+}

package/src/providers/deepseek.js

@@ -3,6 +3,8 @@ import {
   isRetryableError,
   sleep,
   tryParseJSON,
+  ensureJsonResponseFormat,
+  ProviderJsonParseError,
 } from "./base.js";
 
 export async function deepseekChat({
@@ -10,13 +12,16 @@ export async function deepseekChat({
   model = "deepseek-chat",
   temperature = 0.7,
   maxTokens,
-  responseFormat = "json",
+  responseFormat,
   topP,
   frequencyPenalty,
   presencePenalty,
   stop,
   maxRetries = 3,
 }) {
+  // Enforce JSON mode - reject calls without proper JSON responseFormat
+  ensureJsonResponseFormat(responseFormat, "DeepSeek");
+
   if (!process.env.DEEPSEEK_API_KEY) {
     throw new Error("DeepSeek API key not configured");
   }
@@ -44,7 +49,7 @@ export async function deepseekChat({
         stop,
       };
 
-      // Add response format if needed
+      // Add response format - this is now required for all calls
       if (responseFormat?.type === "json_object" || responseFormat === "json") {
         requestBody.response_format = { type: "json_object" };
       }
@@ -71,9 +76,21 @@ export async function deepseekChat({
       const data = await response.json();
       const content = data.choices[0].message.content;
 
+      // Parse JSON - this is now required for all calls
+      const parsed = tryParseJSON(content);
+      if (!parsed) {
+        throw new ProviderJsonParseError(
+          "DeepSeek",
+          model,
+          content.substring(0, 200),
+          "Failed to parse JSON response from DeepSeek API"
+        );
+      }
+
       return {
-        content: tryParseJSON(content),
+        content: parsed,
         usage: data.usage,
+        raw: data,
       };
     } catch (error) {
       lastError = error;
@@ -90,21 +107,3 @@ export async function deepseekChat({
 
   throw lastError || new Error(`Failed after ${maxRetries + 1} attempts`);
 }
-
-// Keep backward compatibility
-export async function queryDeepSeek(
-  system,
-  prompt,
-  model = "deepseek-reasoner"
-) {
-  const response = await deepseekChat({
-    messages: [
-      { role: "system", content: system },
-      { role: "user", content: prompt },
-    ],
-    model,
-    responseFormat: "json",
-  });
-
-  return response.content;
-}