@agenr/agenr-plugin 1.6.0

package/dist/chunk-P5HNPYGQ.js

@@ -0,0 +1,174 @@
+// ../../node_modules/.pnpm/@mariozechner+pi-ai@0.63.2_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__ws@8.20.0_zod@4.3.6/node_modules/@mariozechner/pi-ai/dist/utils/sanitize-unicode.js
+function sanitizeSurrogates(text) {
+  return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
+}
+
+// ../../node_modules/.pnpm/@mariozechner+pi-ai@0.63.2_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__ws@8.20.0_zod@4.3.6/node_modules/@mariozechner/pi-ai/dist/providers/simple-options.js
+function buildBaseOptions(model, options, apiKey) {
+  return {
+    temperature: options?.temperature,
+    maxTokens: options?.maxTokens || Math.min(model.maxTokens, 32e3),
+    signal: options?.signal,
+    apiKey: apiKey || options?.apiKey,
+    cacheRetention: options?.cacheRetention,
+    sessionId: options?.sessionId,
+    headers: options?.headers,
+    onPayload: options?.onPayload,
+    maxRetryDelayMs: options?.maxRetryDelayMs,
+    metadata: options?.metadata
+  };
+}
+function clampReasoning(effort) {
+  return effort === "xhigh" ? "high" : effort;
+}
+function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, reasoningLevel, customBudgets) {
+  const defaultBudgets = {
+    minimal: 1024,
+    low: 2048,
+    medium: 8192,
+    high: 16384
+  };
+  const budgets = { ...defaultBudgets, ...customBudgets };
+  const minOutputTokens = 1024;
+  const level = clampReasoning(reasoningLevel);
+  let thinkingBudget = budgets[level];
+  const maxTokens = Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
+  if (maxTokens <= thinkingBudget) {
+    thinkingBudget = Math.max(0, maxTokens - minOutputTokens);
+  }
+  return { maxTokens, thinkingBudget };
+}
+
+// ../../node_modules/.pnpm/@mariozechner+pi-ai@0.63.2_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__ws@8.20.0_zod@4.3.6/node_modules/@mariozechner/pi-ai/dist/providers/transform-messages.js
+function transformMessages(messages, model, normalizeToolCallId) {
+  const toolCallIdMap = /* @__PURE__ */ new Map();
+  const transformed = messages.map((msg) => {
+    if (msg.role === "user") {
+      return msg;
+    }
+    if (msg.role === "toolResult") {
+      const normalizedId = toolCallIdMap.get(msg.toolCallId);
+      if (normalizedId && normalizedId !== msg.toolCallId) {
+        return { ...msg, toolCallId: normalizedId };
+      }
+      return msg;
+    }
+    if (msg.role === "assistant") {
+      const assistantMsg = msg;
+      const isSameModel = assistantMsg.provider === model.provider && assistantMsg.api === model.api && assistantMsg.model === model.id;
+      const transformedContent = assistantMsg.content.flatMap((block) => {
+        if (block.type === "thinking") {
+          if (block.redacted) {
+            return isSameModel ? block : [];
+          }
+          if (isSameModel && block.thinkingSignature)
+            return block;
+          if (!block.thinking || block.thinking.trim() === "")
+            return [];
+          if (isSameModel)
+            return block;
+          return {
+            type: "text",
+            text: block.thinking
+          };
+        }
+        if (block.type === "text") {
+          if (isSameModel)
+            return block;
+          return {
+            type: "text",
+            text: block.text
+          };
+        }
+        if (block.type === "toolCall") {
+          const toolCall = block;
+          let normalizedToolCall = toolCall;
+          if (!isSameModel && toolCall.thoughtSignature) {
+            normalizedToolCall = { ...toolCall };
+            delete normalizedToolCall.thoughtSignature;
+          }
+          if (!isSameModel && normalizeToolCallId) {
+            const normalizedId = normalizeToolCallId(toolCall.id, model, assistantMsg);
+            if (normalizedId !== toolCall.id) {
+              toolCallIdMap.set(toolCall.id, normalizedId);
+              normalizedToolCall = { ...normalizedToolCall, id: normalizedId };
+            }
+          }
+          return normalizedToolCall;
+        }
+        return block;
+      });
+      return {
+        ...assistantMsg,
+        content: transformedContent
+      };
+    }
+    return msg;
+  });
+  const result = [];
+  let pendingToolCalls = [];
+  let existingToolResultIds = /* @__PURE__ */ new Set();
+  for (let i = 0; i < transformed.length; i++) {
+    const msg = transformed[i];
+    if (msg.role === "assistant") {
+      if (pendingToolCalls.length > 0) {
+        for (const tc of pendingToolCalls) {
+          if (!existingToolResultIds.has(tc.id)) {
+            result.push({
+              role: "toolResult",
+              toolCallId: tc.id,
+              toolName: tc.name,
+              content: [{ type: "text", text: "No result provided" }],
+              isError: true,
+              timestamp: Date.now()
+            });
+          }
+        }
+        pendingToolCalls = [];
+        existingToolResultIds = /* @__PURE__ */ new Set();
+      }
+      const assistantMsg = msg;
+      if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
+        continue;
+      }
+      const toolCalls = assistantMsg.content.filter((b) => b.type === "toolCall");
+      if (toolCalls.length > 0) {
+        pendingToolCalls = toolCalls;
+        existingToolResultIds = /* @__PURE__ */ new Set();
+      }
+      result.push(msg);
+    } else if (msg.role === "toolResult") {
+      existingToolResultIds.add(msg.toolCallId);
+      result.push(msg);
+    } else if (msg.role === "user") {
+      if (pendingToolCalls.length > 0) {
+        for (const tc of pendingToolCalls) {
+          if (!existingToolResultIds.has(tc.id)) {
+            result.push({
+              role: "toolResult",
+              toolCallId: tc.id,
+              toolName: tc.name,
+              content: [{ type: "text", text: "No result provided" }],
+              isError: true,
+              timestamp: Date.now()
+            });
+          }
+        }
+        pendingToolCalls = [];
+        existingToolResultIds = /* @__PURE__ */ new Set();
+      }
+      result.push(msg);
+    } else {
+      result.push(msg);
+    }
+  }
+  return result;
+}
+
+export {
+  sanitizeSurrogates,
+  buildBaseOptions,
+  clampReasoning,
+  adjustMaxTokensForThinking,
+  transformMessages
+};

package/dist/chunk-RD7BUOBD.js

@@ -0,0 +1,416 @@
+import {
+  shortHash
+} from "./chunk-URGOKODJ.js";
+import {
+  parseStreamingJson
+} from "./chunk-JRUUYSFL.js";
+import {
+  sanitizeSurrogates,
+  transformMessages
+} from "./chunk-P5HNPYGQ.js";
+import {
+  calculateCost
+} from "./chunk-OLOUBEE5.js";
+
+// ../../node_modules/.pnpm/@mariozechner+pi-ai@0.63.2_@modelcontextprotocol+sdk@1.27.1_zod@4.3.6__ws@8.20.0_zod@4.3.6/node_modules/@mariozechner/pi-ai/dist/providers/openai-responses-shared.js
+function encodeTextSignatureV1(id, phase) {
+  const payload = { v: 1, id };
+  if (phase)
+    payload.phase = phase;
+  return JSON.stringify(payload);
+}
+function parseTextSignature(signature) {
+  if (!signature)
+    return void 0;
+  if (signature.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(signature);
+      if (parsed.v === 1 && typeof parsed.id === "string") {
+        if (parsed.phase === "commentary" || parsed.phase === "final_answer") {
+          return { id: parsed.id, phase: parsed.phase };
+        }
+        return { id: parsed.id };
+      }
+    } catch {
+    }
+  }
+  return { id: signature };
+}
+function convertResponsesMessages(model, context, allowedToolCallProviders, options) {
+  const messages = [];
+  const normalizeIdPart = (part) => {
+    const sanitized = part.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const normalized = sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
+    return normalized.replace(/_+$/, "");
+  };
+  const buildForeignResponsesItemId = (itemId) => {
+    const normalized = `fc_${shortHash(itemId)}`;
+    return normalized.length > 64 ? normalized.slice(0, 64) : normalized;
+  };
+  const normalizeToolCallId = (id, _targetModel, source) => {
+    if (!allowedToolCallProviders.has(model.provider))
+      return normalizeIdPart(id);
+    if (!id.includes("|"))
+      return normalizeIdPart(id);
+    const [callId, itemId] = id.split("|");
+    const normalizedCallId = normalizeIdPart(callId);
+    const isForeignToolCall = source.provider !== model.provider || source.api !== model.api;
+    let normalizedItemId = isForeignToolCall ? buildForeignResponsesItemId(itemId) : normalizeIdPart(itemId);
+    if (!normalizedItemId.startsWith("fc_")) {
+      normalizedItemId = normalizeIdPart(`fc_${normalizedItemId}`);
+    }
+    return `${normalizedCallId}|${normalizedItemId}`;
+  };
+  const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
+  const includeSystemPrompt = options?.includeSystemPrompt ?? true;
+  if (includeSystemPrompt && context.systemPrompt) {
+    const role = model.reasoning ? "developer" : "system";
+    messages.push({
+      role,
+      content: sanitizeSurrogates(context.systemPrompt)
+    });
+  }
+  let msgIndex = 0;
+  for (const msg of transformedMessages) {
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        messages.push({
+          role: "user",
+          content: [{ type: "input_text", text: sanitizeSurrogates(msg.content) }]
+        });
+      } else {
+        const content = msg.content.map((item) => {
+          if (item.type === "text") {
+            return {
+              type: "input_text",
+              text: sanitizeSurrogates(item.text)
+            };
+          }
+          return {
+            type: "input_image",
+            detail: "auto",
+            image_url: `data:${item.mimeType};base64,${item.data}`
+          };
+        });
+        const filteredContent = !model.input.includes("image") ? content.filter((c) => c.type !== "input_image") : content;
+        if (filteredContent.length === 0)
+          continue;
+        messages.push({
+          role: "user",
+          content: filteredContent
+        });
+      }
+    } else if (msg.role === "assistant") {
+      const output = [];
+      const assistantMsg = msg;
+      const isDifferentModel = assistantMsg.model !== model.id && assistantMsg.provider === model.provider && assistantMsg.api === model.api;
+      for (const block of msg.content) {
+        if (block.type === "thinking") {
+          if (block.thinkingSignature) {
+            const reasoningItem = JSON.parse(block.thinkingSignature);
+            output.push(reasoningItem);
+          }
+        } else if (block.type === "text") {
+          const textBlock = block;
+          const parsedSignature = parseTextSignature(textBlock.textSignature);
+          let msgId = parsedSignature?.id;
+          if (!msgId) {
+            msgId = `msg_${msgIndex}`;
+          } else if (msgId.length > 64) {
+            msgId = `msg_${shortHash(msgId)}`;
+          }
+          output.push({
+            type: "message",
+            role: "assistant",
+            content: [{ type: "output_text", text: sanitizeSurrogates(textBlock.text), annotations: [] }],
+            status: "completed",
+            id: msgId,
+            phase: parsedSignature?.phase
+          });
+        } else if (block.type === "toolCall") {
+          const toolCall = block;
+          const [callId, itemIdRaw] = toolCall.id.split("|");
+          let itemId = itemIdRaw;
+          if (isDifferentModel && itemId?.startsWith("fc_")) {
+            itemId = void 0;
+          }
+          output.push({
+            type: "function_call",
+            id: itemId,
+            call_id: callId,
+            name: toolCall.name,
+            arguments: JSON.stringify(toolCall.arguments)
+          });
+        }
+      }
+      if (output.length === 0)
+        continue;
+      messages.push(...output);
+    } else if (msg.role === "toolResult") {
+      const textResult = msg.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+      const hasImages = msg.content.some((c) => c.type === "image");
+      const hasText = textResult.length > 0;
+      const [callId] = msg.toolCallId.split("|");
+      let output;
+      if (hasImages && model.input.includes("image")) {
+        const contentParts = [];
+        if (hasText) {
+          contentParts.push({
+            type: "input_text",
+            text: sanitizeSurrogates(textResult)
+          });
+        }
+        for (const block of msg.content) {
+          if (block.type === "image") {
+            contentParts.push({
+              type: "input_image",
+              detail: "auto",
+              image_url: `data:${block.mimeType};base64,${block.data}`
+            });
+          }
+        }
+        output = contentParts;
+      } else {
+        output = sanitizeSurrogates(hasText ? textResult : "(see attached image)");
+      }
+      messages.push({
+        type: "function_call_output",
+        call_id: callId,
+        output
+      });
+    }
+    msgIndex++;
+  }
+  return messages;
+}
+function convertResponsesTools(tools, options) {
+  const strict = options?.strict === void 0 ? false : options.strict;
+  return tools.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters,
+    // TypeBox already generates JSON Schema
+    strict
+  }));
+}
+async function processResponsesStream(openaiStream, output, stream, model, options) {
+  let currentItem = null;
+  let currentBlock = null;
+  const blocks = output.content;
+  const blockIndex = () => blocks.length - 1;
+  for await (const event of openaiStream) {
+    if (event.type === "response.created") {
+      output.responseId = event.response.id;
+    } else if (event.type === "response.output_item.added") {
+      const item = event.item;
+      if (item.type === "reasoning") {
+        currentItem = item;
+        currentBlock = { type: "thinking", thinking: "" };
+        output.content.push(currentBlock);
+        stream.push({ type: "thinking_start", contentIndex: blockIndex(), partial: output });
+      } else if (item.type === "message") {
+        currentItem = item;
+        currentBlock = { type: "text", text: "" };
+        output.content.push(currentBlock);
+        stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
+      } else if (item.type === "function_call") {
+        currentItem = item;
+        currentBlock = {
+          type: "toolCall",
+          id: `${item.call_id}|${item.id}`,
+          name: item.name,
+          arguments: {},
+          partialJson: item.arguments || ""
+        };
+        output.content.push(currentBlock);
+        stream.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
+      }
+    } else if (event.type === "response.reasoning_summary_part.added") {
+      if (currentItem && currentItem.type === "reasoning") {
+        currentItem.summary = currentItem.summary || [];
+        currentItem.summary.push(event.part);
+      }
+    } else if (event.type === "response.reasoning_summary_text.delta") {
+      if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
+        currentItem.summary = currentItem.summary || [];
+        const lastPart = currentItem.summary[currentItem.summary.length - 1];
+        if (lastPart) {
+          currentBlock.thinking += event.delta;
+          lastPart.text += event.delta;
+          stream.push({
+            type: "thinking_delta",
+            contentIndex: blockIndex(),
+            delta: event.delta,
+            partial: output
+          });
+        }
+      }
+    } else if (event.type === "response.reasoning_summary_part.done") {
+      if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
+        currentItem.summary = currentItem.summary || [];
+        const lastPart = currentItem.summary[currentItem.summary.length - 1];
+        if (lastPart) {
+          currentBlock.thinking += "\n\n";
+          lastPart.text += "\n\n";
+          stream.push({
+            type: "thinking_delta",
+            contentIndex: blockIndex(),
+            delta: "\n\n",
+            partial: output
+          });
+        }
+      }
+    } else if (event.type === "response.content_part.added") {
+      if (currentItem?.type === "message") {
+        currentItem.content = currentItem.content || [];
+        if (event.part.type === "output_text" || event.part.type === "refusal") {
+          currentItem.content.push(event.part);
+        }
+      }
+    } else if (event.type === "response.output_text.delta") {
+      if (currentItem?.type === "message" && currentBlock?.type === "text") {
+        if (!currentItem.content || currentItem.content.length === 0) {
+          continue;
+        }
+        const lastPart = currentItem.content[currentItem.content.length - 1];
+        if (lastPart?.type === "output_text") {
+          currentBlock.text += event.delta;
+          lastPart.text += event.delta;
+          stream.push({
+            type: "text_delta",
+            contentIndex: blockIndex(),
+            delta: event.delta,
+            partial: output
+          });
+        }
+      }
+    } else if (event.type === "response.refusal.delta") {
+      if (currentItem?.type === "message" && currentBlock?.type === "text") {
+        if (!currentItem.content || currentItem.content.length === 0) {
+          continue;
+        }
+        const lastPart = currentItem.content[currentItem.content.length - 1];
+        if (lastPart?.type === "refusal") {
+          currentBlock.text += event.delta;
+          lastPart.refusal += event.delta;
+          stream.push({
+            type: "text_delta",
+            contentIndex: blockIndex(),
+            delta: event.delta,
+            partial: output
+          });
+        }
+      }
+    } else if (event.type === "response.function_call_arguments.delta") {
+      if (currentItem?.type === "function_call" && currentBlock?.type === "toolCall") {
+        currentBlock.partialJson += event.delta;
+        currentBlock.arguments = parseStreamingJson(currentBlock.partialJson);
+        stream.push({
+          type: "toolcall_delta",
+          contentIndex: blockIndex(),
+          delta: event.delta,
+          partial: output
+        });
+      }
+    } else if (event.type === "response.function_call_arguments.done") {
+      if (currentItem?.type === "function_call" && currentBlock?.type === "toolCall") {
+        currentBlock.partialJson = event.arguments;
+        currentBlock.arguments = parseStreamingJson(currentBlock.partialJson);
+      }
+    } else if (event.type === "response.output_item.done") {
+      const item = event.item;
+      if (item.type === "reasoning" && currentBlock?.type === "thinking") {
+        currentBlock.thinking = item.summary?.map((s) => s.text).join("\n\n") || "";
+        currentBlock.thinkingSignature = JSON.stringify(item);
+        stream.push({
+          type: "thinking_end",
+          contentIndex: blockIndex(),
+          content: currentBlock.thinking,
+          partial: output
+        });
+        currentBlock = null;
+      } else if (item.type === "message" && currentBlock?.type === "text") {
+        currentBlock.text = item.content.map((c) => c.type === "output_text" ? c.text : c.refusal).join("");
+        currentBlock.textSignature = encodeTextSignatureV1(item.id, item.phase ?? void 0);
+        stream.push({
+          type: "text_end",
+          contentIndex: blockIndex(),
+          content: currentBlock.text,
+          partial: output
+        });
+        currentBlock = null;
+      } else if (item.type === "function_call") {
+        const args = currentBlock?.type === "toolCall" && currentBlock.partialJson ? parseStreamingJson(currentBlock.partialJson) : parseStreamingJson(item.arguments || "{}");
+        const toolCall = {
+          type: "toolCall",
+          id: `${item.call_id}|${item.id}`,
+          name: item.name,
+          arguments: args
+        };
+        currentBlock = null;
+        stream.push({ type: "toolcall_end", contentIndex: blockIndex(), toolCall, partial: output });
+      }
+    } else if (event.type === "response.completed") {
+      const response = event.response;
+      if (response?.id) {
+        output.responseId = response.id;
+      }
+      if (response?.usage) {
+        const cachedTokens = response.usage.input_tokens_details?.cached_tokens || 0;
+        output.usage = {
+          // OpenAI includes cached tokens in input_tokens, so subtract to get non-cached input
+          input: (response.usage.input_tokens || 0) - cachedTokens,
+          output: response.usage.output_tokens || 0,
+          cacheRead: cachedTokens,
+          cacheWrite: 0,
+          totalTokens: response.usage.total_tokens || 0,
+          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+        };
+      }
+      calculateCost(model, output.usage);
+      if (options?.applyServiceTierPricing) {
+        const serviceTier = response?.service_tier ?? options.serviceTier;
+        options.applyServiceTierPricing(output.usage, serviceTier);
+      }
+      output.stopReason = mapStopReason(response?.status);
+      if (output.content.some((b) => b.type === "toolCall") && output.stopReason === "stop") {
+        output.stopReason = "toolUse";
+      }
+    } else if (event.type === "error") {
+      throw new Error(`Error Code ${event.code}: ${event.message}` || "Unknown error");
+    } else if (event.type === "response.failed") {
+      const error = event.response?.error;
+      const details = event.response?.incomplete_details;
+      const msg = error ? `${error.code || "unknown"}: ${error.message || "no message"}` : details?.reason ? `incomplete: ${details.reason}` : "Unknown error (no error details in response)";
+      throw new Error(msg);
+    }
+  }
+}
+function mapStopReason(status) {
+  if (!status)
+    return "stop";
+  switch (status) {
+    case "completed":
+      return "stop";
+    case "incomplete":
+      return "length";
+    case "failed":
+    case "cancelled":
+      return "error";
+    // These two are wonky ...
+    case "in_progress":
+    case "queued":
+      return "stop";
+    default: {
+      const _exhaustive = status;
+      throw new Error(`Unhandled stop reason: ${_exhaustive}`);
+    }
+  }
+}
+
+export {
+  convertResponsesMessages,
+  convertResponsesTools,
+  processResponsesStream
+};