@goah/cli 0.13.0 → 0.13.2

package/dist/openai-responses-HMCXJIHT.js

@@ -0,0 +1,300 @@
+import { createRequire as __goahCreateRequire } from "node:module";
+const require = __goahCreateRequire(import.meta.url);
+import {
+  splitDeferredTools
+} from "./chunk-LKBKZEHT.js";
+import {
+  buildCopilotDynamicHeaders,
+  hasCopilotVisionInput
+} from "./chunk-JQD5EWJY.js";
+import {
+  convertResponsesMessages,
+  convertResponsesTools,
+  processResponsesStream
+} from "./chunk-25XSBFX6.js";
+import {
+  clampOpenAIPromptCacheKey
+} from "./chunk-7AXAFDPG.js";
+import "./chunk-4US7ZHT3.js";
+import {
+  OpenAI
+} from "./chunk-LBKI23CC.js";
+import {
+  formatProviderError,
+  normalizeProviderError
+} from "./chunk-H462EFJP.js";
+import {
+  buildBaseOptions,
+  createGrammarToolInputProperties
+} from "./chunk-BXA47DTF.js";
+import {
+  retryProviderRequest
+} from "./chunk-4M6TXTT5.js";
+import "./chunk-NRLGWZJC.js";
+import {
+  headersToRecord
+} from "./chunk-FSBUS2BI.js";
+import {
+  getProviderEnvValue
+} from "./chunk-IIJQ3DW4.js";
+import "./chunk-2ZP2NBW3.js";
+import {
+  clampThinkingLevel
+} from "./chunk-MPXK7QBL.js";
+import {
+  AssistantMessageEventStream
+} from "./chunk-2QBQZGXF.js";
+import "./chunk-XPQKM3L7.js";
+
+// ../../node_modules/@earendil-works/pi-ai/dist/api/openai-responses.js
+var OPENAI_TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set(["openai", "openai-codex", "opencode"]);
+var OPENAI_RESPONSES_MIN_OUTPUT_TOKENS = 16;
+function hasHeader(headers, name) {
+  if (!headers)
+    return false;
+  const expected = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === expected && value !== null && value.trim().length > 0)
+      return true;
+  }
+  return false;
+}
+function getClientApiKey(provider, apiKey, headers) {
+  if (apiKey)
+    return apiKey;
+  if (hasHeader(headers, "authorization") || hasHeader(headers, "cf-aig-authorization"))
+    return "unused";
+  throw new Error(`No API key for provider: ${provider}`);
+}
+function detectSessionAffinityFormat(model) {
+  return model.provider === "openrouter" || model.baseUrl.includes("openrouter.ai") ? "openrouter" : "openai";
+}
+function resolveCacheRetention(cacheRetention, env) {
+  if (cacheRetention) {
+    return cacheRetention;
+  }
+  if (getProviderEnvValue("PI_CACHE_RETENTION", env) === "long") {
+    return "long";
+  }
+  return "short";
+}
+function getCompat(model) {
+  return {
+    supportsDeveloperRole: model.compat?.supportsDeveloperRole ?? true,
+    sessionAffinityFormat: model.compat?.sessionAffinityFormat ?? detectSessionAffinityFormat(model),
+    supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true,
+    supportsStrictMode: model.compat?.supportsStrictMode ?? false,
+    supportsOpenAIGrammarTools: model.compat?.supportsOpenAIGrammarTools ?? false,
+    supportsAdditionalTools: model.compat?.supportsAdditionalTools ?? false,
+    supportsToolSearch: model.compat?.supportsToolSearch ?? false,
+    supportsExplicitPromptCacheMode: model.compat?.supportsExplicitPromptCacheMode ?? false
+  };
+}
+function getPromptCacheRetention(compat, cacheRetention) {
+  return cacheRetention === "long" && compat.supportsLongCacheRetention ? "24h" : void 0;
+}
+function formatOpenAIResponsesError(error) {
+  return formatProviderError(normalizeProviderError(error), "OpenAI API error");
+}
+var stream = (model, context, options) => {
+  const stream2 = new AssistantMessageEventStream();
+  (async () => {
+    const output = {
+      role: "assistant",
+      content: [],
+      api: model.api,
+      provider: model.provider,
+      model: model.id,
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+      },
+      stopReason: "pending",
+      timestamp: Date.now()
+    };
+    try {
+      const apiKey = getClientApiKey(model.provider, options?.apiKey, options?.headers);
+      const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
+      const cacheSessionId = cacheRetention === "none" ? void 0 : options?.sessionId;
+      const compat = getCompat(model);
+      const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, compat.supportsOpenAIGrammarTools);
+      const client = createClient(model, context, apiKey, options?.headers, options?.fetch, cacheSessionId);
+      let params = buildParams(model, context, options, compat, grammarToolInputProperties);
+      const nextParams = await options?.onPayload?.(params, model);
+      if (nextParams !== void 0) {
+        params = nextParams;
+      }
+      const requestOptions = {
+        ...options?.signal ? { signal: options.signal } : {},
+        ...options?.timeoutMs !== void 0 ? { timeout: options.timeoutMs } : {},
+        maxRetries: 0
+      };
+      const { data: openaiStream, response } = await retryProviderRequest(() => client.responses.create(params, requestOptions).withResponse(), {
+        maxRetries: options?.maxRetries,
+        maxRetryDelayMs: options?.maxRetryDelayMs,
+        signal: options?.signal
+      });
+      await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
+      stream2.push({ type: "start", partial: output });
+      await processResponsesStream(openaiStream, output, stream2, model, {
+        serviceTier: options?.serviceTier,
+        grammarToolInputProperties,
+        applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model)
+      });
+      if (options?.signal?.aborted) {
+        throw new Error("Request was aborted");
+      }
+      if (output.stopReason === "pending") {
+        throw new Error("OpenAI Responses stream ended without a stop reason");
+      }
+      if (output.stopReason === "aborted" || output.stopReason === "error") {
+        throw new Error(output.errorMessage || "An unknown error occurred");
+      }
+      stream2.push({ type: "done", reason: output.stopReason, message: output });
+      stream2.end();
+    } catch (error) {
+      for (const block of output.content) {
+        delete block.index;
+        delete block.partialJson;
+        delete block.customInput;
+      }
+      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      output.errorMessage = formatOpenAIResponsesError(error);
+      stream2.push({ type: "error", reason: output.stopReason, error: output });
+      stream2.end();
+    }
+  })();
+  return stream2;
+};
+var streamSimple = (model, context, options) => {
+  getClientApiKey(model.provider, options?.apiKey, options?.headers);
+  const base = buildBaseOptions(model, context, options, options?.apiKey);
+  const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : void 0;
+  const reasoningEffort = clampedReasoning === "off" ? void 0 : clampedReasoning;
+  return stream(model, context, {
+    ...base,
+    reasoningEffort
+  });
+};
+function createClient(model, context, apiKey, optionsHeaders, fetch, sessionId) {
+  const compat = getCompat(model);
+  const headers = { ...model.headers };
+  if (model.provider === "github-copilot") {
+    const hasImages = hasCopilotVisionInput(context.messages);
+    const copilotHeaders = buildCopilotDynamicHeaders({
+      messages: context.messages,
+      hasImages
+    });
+    Object.assign(headers, copilotHeaders);
+  }
+  if (sessionId) {
+    if (compat.sessionAffinityFormat === "openrouter") {
+      headers["x-session-id"] = sessionId;
+    } else {
+      if (compat.sessionAffinityFormat === "openai") {
+        headers.session_id = sessionId;
+      }
+      headers["x-client-request-id"] = sessionId;
+    }
+  }
+  if (optionsHeaders) {
+    Object.assign(headers, optionsHeaders);
+  }
+  return new OpenAI({
+    apiKey,
+    baseURL: model.baseUrl,
+    dangerouslyAllowBrowser: true,
+    fetch,
+    defaultHeaders: headers
+  });
+}
+function buildParams(model, context, options, compat = getCompat(model), grammarToolInputProperties = createGrammarToolInputProperties(context.tools, compat.supportsOpenAIGrammarTools)) {
+  const deferredToolsMode = compat.supportsAdditionalTools ? "additional-tools" : compat.supportsToolSearch ? "tool-search" : void 0;
+  const toolPlacement = splitDeferredTools(context, deferredToolsMode !== void 0);
+  const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS, {
+    grammarToolInputProperties,
+    deferredTools: toolPlacement.deferred,
+    deferredToolsMode,
+    toolOptions: {
+      supportsStrictMode: compat.supportsStrictMode,
+      supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools
+    }
+  });
+  const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
+  const disableImplicitPromptCache = cacheRetention === "none" && compat.supportsExplicitPromptCacheMode;
+  const params = {
+    model: model.id,
+    input: messages,
+    stream: true,
+    prompt_cache_key: cacheRetention === "none" ? void 0 : clampOpenAIPromptCacheKey(options?.sessionId),
+    prompt_cache_retention: getPromptCacheRetention(compat, cacheRetention),
+    prompt_cache_options: disableImplicitPromptCache ? { mode: "explicit" } : void 0,
+    store: false
+  };
+  if (options?.maxTokens) {
+    params.max_output_tokens = Math.max(options.maxTokens, OPENAI_RESPONSES_MIN_OUTPUT_TOKENS);
+  }
+  if (options?.temperature !== void 0) {
+    params.temperature = options?.temperature;
+  }
+  if (options?.serviceTier !== void 0) {
+    params.service_tier = options.serviceTier;
+  }
+  if (toolPlacement.immediate.length > 0) {
+    params.tools = convertResponsesTools(toolPlacement.immediate, {
+      supportsStrictMode: compat.supportsStrictMode,
+      supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools
+    });
+  }
+  if (options?.toolChoice !== void 0) {
+    params.tool_choice = options.toolChoice;
+  }
+  if (model.reasoning) {
+    if (options?.reasoningEffort || options?.reasoningSummary) {
+      const effort = options?.reasoningEffort ? model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort : "medium";
+      params.reasoning = {
+        effort,
+        summary: options?.reasoningSummary || "auto"
+      };
+      params.include = ["reasoning.encrypted_content"];
+    } else if (model.provider !== "github-copilot" && model.thinkingLevelMap?.off !== null) {
+      params.reasoning = {
+        effort: model.thinkingLevelMap?.off ?? "none"
+      };
+    }
+    if (model.provider === "xai")
+      params.include = ["reasoning.encrypted_content"];
+  }
+  if (options?.samplingParams) {
+    Object.assign(params, options.samplingParams);
+  }
+  return params;
+}
+function getServiceTierCostMultiplier(model, serviceTier) {
+  switch (serviceTier) {
+    case "flex":
+      return 0.5;
+    case "priority":
+      return model.id === "gpt-5.5" ? 2.5 : 2;
+    default:
+      return 1;
+  }
+}
+function applyServiceTierPricing(usage, serviceTier, model) {
+  const multiplier = getServiceTierCostMultiplier(model, serviceTier);
+  if (multiplier === 1)
+    return;
+  usage.cost.input *= multiplier;
+  usage.cost.output *= multiplier;
+  usage.cost.cacheRead *= multiplier;
+  usage.cost.cacheWrite *= multiplier;
+  usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+}
+export {
+  stream,
+  streamSimple
+};

package/dist/openrouter-images-KTWET2H2.js

@@ -0,0 +1,148 @@
+import { createRequire as __goahCreateRequire } from "node:module";
+const require = __goahCreateRequire(import.meta.url);
+import {
+  OpenAI
+} from "./chunk-LBKI23CC.js";
+import {
+  formatProviderError,
+  normalizeProviderError
+} from "./chunk-H462EFJP.js";
+import {
+  retryProviderRequest
+} from "./chunk-4M6TXTT5.js";
+import {
+  sanitizeSurrogates
+} from "./chunk-NRLGWZJC.js";
+import {
+  headersToRecord,
+  providerHeadersToRecord
+} from "./chunk-FSBUS2BI.js";
+import "./chunk-XPQKM3L7.js";
+
+// ../../node_modules/@earendil-works/pi-ai/dist/api/openrouter-images.js
+var generateImages = async (model, context, options) => {
+  const output = {
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    output: [],
+    stopReason: "stop",
+    timestamp: Date.now()
+  };
+  try {
+    const apiKey = options?.apiKey;
+    if (!apiKey) {
+      throw new Error(`No API key for provider: ${model.provider}`);
+    }
+    const client = createClient(model, apiKey, options?.headers, options?.fetch);
+    let params = buildParams(model, context);
+    const nextParams = await options?.onPayload?.(params, model);
+    if (nextParams !== void 0) {
+      params = nextParams;
+    }
+    const requestOptions = {
+      ...options?.signal ? { signal: options.signal } : {},
+      ...options?.timeoutMs !== void 0 ? { timeout: options.timeoutMs } : {},
+      maxRetries: 0
+    };
+    const { data: response, response: rawResponse } = await retryProviderRequest(() => client.chat.completions.create(params, requestOptions).withResponse(), {
+      maxRetries: options?.maxRetries,
+      maxRetryDelayMs: options?.maxRetryDelayMs,
+      signal: options?.signal
+    });
+    await options?.onResponse?.({ status: rawResponse.status, headers: headersToRecord(rawResponse.headers) }, model);
+    const imageResponse = response;
+    output.responseId = imageResponse.id;
+    if (imageResponse.usage) {
+      output.usage = parseUsage(imageResponse.usage, model);
+    }
+    const choice = imageResponse.choices[0];
+    if (choice) {
+      const content = choice.message.content;
+      if (typeof content === "string" && content.length > 0) {
+        output.output.push({ type: "text", text: content });
+      }
+      for (const image of choice.message.images ?? []) {
+        const imageUrl = typeof image.image_url === "string" ? image.image_url : image.image_url?.url;
+        if (!imageUrl?.startsWith("data:"))
+          continue;
+        const matches = imageUrl.match(/^data:([^;]+);base64,(.+)$/);
+        if (!matches)
+          continue;
+        output.output.push({
+          type: "image",
+          mimeType: matches[1],
+          data: matches[2]
+        });
+      }
+    }
+    return output;
+  } catch (error) {
+    output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+    output.errorMessage = formatProviderError(normalizeProviderError(error));
+    return output;
+  }
+};
+function createClient(model, apiKey, optionsHeaders, fetch) {
+  return new OpenAI({
+    apiKey,
+    baseURL: model.baseUrl,
+    dangerouslyAllowBrowser: true,
+    fetch,
+    defaultHeaders: providerHeadersToRecord({ ...model.headers, ...optionsHeaders })
+  });
+}
+function buildParams(model, context) {
+  const content = context.input.map((item) => {
+    if (item.type === "text") {
+      return {
+        type: "text",
+        text: sanitizeSurrogates(item.text)
+      };
+    }
+    return {
+      type: "image_url",
+      image_url: {
+        url: `data:${item.mimeType};base64,${item.data}`
+      }
+    };
+  });
+  return {
+    model: model.id,
+    messages: [
+      {
+        role: "user",
+        content
+      }
+    ],
+    stream: false,
+    modalities: model.output.includes("text") ? ["image", "text"] : ["image"]
+  };
+}
+function parseUsage(rawUsage, model) {
+  const promptTokens = rawUsage.prompt_tokens || 0;
+  const reportedCachedTokens = rawUsage.prompt_tokens_details?.cached_tokens || 0;
+  const cacheWriteTokens = rawUsage.prompt_tokens_details?.cache_write_tokens || 0;
+  const cacheReadTokens = cacheWriteTokens > 0 ? Math.max(0, reportedCachedTokens - cacheWriteTokens) : reportedCachedTokens;
+  const input = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
+  const output = rawUsage.completion_tokens || 0;
+  const usage = {
+    input,
+    output,
+    cacheRead: cacheReadTokens,
+    cacheWrite: cacheWriteTokens,
+    totalTokens: input + output + cacheReadTokens + cacheWriteTokens,
+    cost: {
+      input: model.cost.input / 1e6 * input,
+      output: model.cost.output / 1e6 * output,
+      cacheRead: model.cost.cacheRead / 1e6 * cacheReadTokens,
+      cacheWrite: model.cost.cacheWrite / 1e6 * cacheWriteTokens,
+      total: 0
+    }
+  };
+  usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+  return usage;
+}
+export {
+  generateImages
+};