@polos/sdk 0.1.2 → 0.1.3

package/dist/index.cjs

@@ -56,9 +56,6 @@ function createWorkflowRegistry() {
   const workflows = /* @__PURE__ */ new Map();
   return {
     register(workflow) {
-      if (workflows.has(workflow.id)) {
-        throw new DuplicateWorkflowError(workflow.id);
-      }
       workflows.set(workflow.id, workflow);
     },
     get(workflowId) {
@@ -1810,11 +1807,18 @@ function convertMiddlewareToolCallToPython(tc) {
 function convertVercelUsageToPython(usage) {
   const input = usage.inputTokens ?? 0;
   const output = usage.outputTokens ?? 0;
-  return {
+  const result = {
     input_tokens: input,
     output_tokens: output,
     total_tokens: usage.totalTokens ?? input + output
   };
+  if (usage.inputTokenDetails?.cacheReadTokens != null) {
+    result.cache_read_input_tokens = usage.inputTokenDetails.cacheReadTokens;
+  }
+  if (usage.inputTokenDetails?.cacheWriteTokens != null) {
+    result.cache_creation_input_tokens = usage.inputTokenDetails.cacheWriteTokens;
+  }
+  return result;
 }
 function convertFinishReason(reason) {
   if (!reason) return null;
@@ -1829,6 +1833,41 @@ function convertFinishReason(reason) {
 }
 
 // src/llm/llm.ts
+var ANTHROPIC_CACHE_BREAKPOINT = {
+  anthropic: { cacheControl: { type: "ephemeral" } }
+};
+function isAnthropicModel(model) {
+  return getModelProvider(model).startsWith("anthropic");
+}
+function applyAnthropicCacheControl(args, model) {
+  if (!isAnthropicModel(model)) return;
+  if (typeof args["system"] === "string") {
+    args["system"] = {
+      role: "system",
+      content: args["system"],
+      providerOptions: ANTHROPIC_CACHE_BREAKPOINT
+    };
+  }
+  const tools = args["tools"];
+  if (tools) {
+    const toolNames = Object.keys(tools);
+    if (toolNames.length > 0) {
+      const lastToolName = toolNames[toolNames.length - 1];
+      tools[lastToolName] = {
+        ...tools[lastToolName],
+        providerOptions: ANTHROPIC_CACHE_BREAKPOINT
+      };
+    }
+  }
+  const messages = args["messages"];
+  if (messages && messages.length > 0) {
+    const lastMsg = messages[messages.length - 1];
+    messages[messages.length - 1] = {
+      ...lastMsg,
+      providerOptions: ANTHROPIC_CACHE_BREAKPOINT
+    };
+  }
+}
 function buildGenerateArgs(model, messages, options) {
   const args = { model, messages };
   const tools = convertToolsToVercel(options.tools);
@@ -1840,6 +1879,7 @@ function buildGenerateArgs(model, messages, options) {
   if (options.outputSchema) {
     args["experimental_output"] = ai.Output.object({ schema: options.outputSchema });
   }
+  applyAnthropicCacheControl(args, model);
   return args;
 }
 var LLM = class {
@@ -2585,6 +2625,8 @@ async function agentStreamFunction(ctx, payload, agentDef) {
   let finalInputTokens = 0;
   let finalOutputTokens = 0;
   let finalTotalTokens = 0;
+  let finalCacheReadInputTokens = 0;
+  let finalCacheCreationInputTokens = 0;
   let lastLlmResultContent = null;
   const allToolResults = [];
   const steps = [];
@@ -2715,6 +2757,12 @@ async function agentStreamFunction(ctx, payload, agentDef) {
       finalInputTokens += llmResult.usage.input_tokens;
       finalOutputTokens += llmResult.usage.output_tokens;
       finalTotalTokens += llmResult.usage.total_tokens;
+      if (llmResult.usage.cache_read_input_tokens) {
+        finalCacheReadInputTokens += llmResult.usage.cache_read_input_tokens;
+      }
+      if (llmResult.usage.cache_creation_input_tokens) {
+        finalCacheCreationInputTokens += llmResult.usage.cache_creation_input_tokens;
+      }
     }
     lastLlmResultContent = llmResult.content;
     const toolCalls = llmResult.tool_calls ?? [];
@@ -2938,7 +2986,11 @@ Please provide ONLY valid JSON that matches the schema, with no additional text
     usage: {
       input_tokens: finalInputTokens,
       output_tokens: finalOutputTokens,
-      total_tokens: finalTotalTokens
+      total_tokens: finalTotalTokens,
+      ...finalCacheReadInputTokens > 0 && { cache_read_input_tokens: finalCacheReadInputTokens },
+      ...finalCacheCreationInputTokens > 0 && {
+        cache_creation_input_tokens: finalCacheCreationInputTokens
+      }
     }
   };
 }
@@ -3099,7 +3151,7 @@ function defineAgent(config) {
         maxOutputTokens: config.maxOutputTokens
       },
       input,
-      streaming: streamingFlag ?? false,
+      streaming: streamingFlag ?? config.streamToWorkflow ?? false,
       conversation_id: conversationIdValue
     };
     return agentStreamFunction(ctx, streamPayload, {
@@ -5803,6 +5855,13 @@ var DEFAULT_TIMEOUT_SECONDS = 300;
 var DEFAULT_MAX_OUTPUT_CHARS = 1e5;
 function spawnCommand(command, args, options) {
   return new Promise((resolve8, reject) => {
+    let settled = false;
+    const settle = (fn) => {
+      if (!settled) {
+        settled = true;
+        fn();
+      }
+    };
     const proc = child_process.spawn(command, args, { stdio: ["pipe", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -5813,6 +5872,12 @@ function spawnCommand(command, args, options) {
     proc.stderr.on("data", (data) => {
       stderr += data.toString();
     });
+    proc.stdin.on("error", () => {
+    });
+    proc.stdout.on("error", () => {
+    });
+    proc.stderr.on("error", () => {
+    });
     const timeoutMs = (options?.timeout ?? DEFAULT_TIMEOUT_SECONDS) * 1e3;
     const timer = setTimeout(() => {
       killed = true;
@@ -5820,24 +5885,31 @@ function spawnCommand(command, args, options) {
     }, timeoutMs);
     proc.on("close", (code) => {
       clearTimeout(timer);
-      if (killed) {
-        resolve8({
-          exitCode: 137,
-          stdout,
-          stderr: stderr + "\n[Process killed: timeout exceeded]"
-        });
-      } else {
-        resolve8({ exitCode: code ?? 1, stdout, stderr });
-      }
+      settle(() => {
+        if (killed) {
+          resolve8({
+            exitCode: 137,
+            stdout,
+            stderr: stderr + "\n[Process killed: timeout exceeded]"
+          });
+        } else {
+          resolve8({ exitCode: code ?? 1, stdout, stderr });
+        }
+      });
     });
     proc.on("error", (err) => {
       clearTimeout(timer);
-      reject(err);
+      settle(() => {
+        reject(err);
+      });
     });
     if (options?.stdin) {
-      proc.stdin.write(options.stdin);
+      proc.stdin.write(options.stdin, () => {
+        proc.stdin.end();
+      });
+    } else {
+      proc.stdin.end();
     }
-    proc.stdin.end();
   });
 }
 var DockerEnvironment = class {
@@ -5893,7 +5965,7 @@ var DockerEnvironment = class {
   }
   async exec(command, opts) {
     this.assertInitialized();
-    const args = ["exec", "-i"];
+    const args = opts?.stdin ? ["exec", "-i"] : ["exec"];
     const cwd = opts?.cwd ?? this.containerWorkdir;
     args.push("-w", cwd);
     if (opts?.env) {
@@ -6028,6 +6100,13 @@ var DEFAULT_TIMEOUT_SECONDS2 = 300;
 var DEFAULT_MAX_OUTPUT_CHARS2 = 1e5;
 function spawnLocal(command, options) {
   return new Promise((resolve8, reject) => {
+    let settled = false;
+    const settle = (fn) => {
+      if (!settled) {
+        settled = true;
+        fn();
+      }
+    };
     const proc = child_process.spawn("sh", ["-c", command], {
       cwd: options.cwd,
       env: options.env ? { ...process.env, ...options.env } : void 0,
@@ -6042,6 +6121,12 @@ function spawnLocal(command, options) {
     proc.stderr.on("data", (data) => {
       stderr += data.toString();
     });
+    proc.stdin.on("error", () => {
+    });
+    proc.stdout.on("error", () => {
+    });
+    proc.stderr.on("error", () => {
+    });
     const timeoutMs = (options.timeout ?? DEFAULT_TIMEOUT_SECONDS2) * 1e3;
     const timer = setTimeout(() => {
       killed = true;
@@ -6049,24 +6134,31 @@ function spawnLocal(command, options) {
     }, timeoutMs);
     proc.on("close", (code) => {
       clearTimeout(timer);
-      if (killed) {
-        resolve8({
-          exitCode: 137,
-          stdout,
-          stderr: stderr + "\n[Process killed: timeout exceeded]"
-        });
-      } else {
-        resolve8({ exitCode: code ?? 1, stdout, stderr });
-      }
+      settle(() => {
+        if (killed) {
+          resolve8({
+            exitCode: 137,
+            stdout,
+            stderr: stderr + "\n[Process killed: timeout exceeded]"
+          });
+        } else {
+          resolve8({ exitCode: code ?? 1, stdout, stderr });
+        }
+      });
     });
     proc.on("error", (err) => {
       clearTimeout(timer);
-      reject(err);
+      settle(() => {
+        reject(err);
+      });
     });
     if (options.stdin) {
-      proc.stdin.write(options.stdin);
+      proc.stdin.write(options.stdin, () => {
+        proc.stdin.end();
+      });
+    } else {
+      proc.stdin.end();
     }
-    proc.stdin.end();
   });
 }
 var LocalEnvironment = class {