privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-3UVHLQDJ.mjs

@@ -0,0 +1,225 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  convertResponsesMessages,
+  convertResponsesTools,
+  processResponsesStream
+} from "./c-4D5UMWVW.mjs";
+import {
+  clampOpenAIPromptCacheKey
+} from "./c-UU4WZPPE.mjs";
+import "./c-BKF2O6BL.mjs";
+import {
+  AzureOpenAI
+} from "./c-Q4HYCRLB.mjs";
+import {
+  formatProviderError,
+  normalizeProviderError
+} from "./c-ZWUVHKMK.mjs";
+import {
+  buildBaseOptions,
+  createGrammarToolInputProperties,
+  getPiUserAgent,
+  resolveSamplingParams
+} from "./c-C6S2YB53.mjs";
+import "./c-5GV3X3RB.mjs";
+import {
+  retryProviderRequest
+} from "./c-EYZGSAJU.mjs";
+import {
+  headersToRecord
+} from "./c-ZJYLGIC3.mjs";
+import {
+  resolveAzureConfig,
+  resolveDeploymentName
+} from "./c-2G3BBHRJ.mjs";
+import "./c-CDBEJSBF.mjs";
+import "./c-DEE67DJO.mjs";
+import {
+  clampThinkingLevel,
+  getDeclaredTools,
+  resolveTranscript,
+  resolveTranscriptTools
+} from "./c-WO3QSZUU.mjs";
+import {
+  AssistantMessageEventStream
+} from "./c-S2RVHR3M.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/@earendil-works/pi-ai/dist/api/azure-openai-responses.js
+var AZURE_TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set(["openai", "openai-codex", "opencode", "azure"]);
+var OPENAI_RESPONSES_MIN_OUTPUT_TOKENS = 16;
+function formatAzureOpenAIError(error) {
+  return formatProviderError(normalizeProviderError(error), "Azure OpenAI API error");
+}
+__name(formatAzureOpenAIError, "formatAzureOpenAIError");
+var stream = /* @__PURE__ */ __name((model, context, options) => {
+  const stream2 = new AssistantMessageEventStream();
+  const normalizedContext = resolveTranscript(context, model.compat?.supportsMidConvoSystemMessages);
+  (async () => {
+    const deploymentName = resolveDeploymentName(model, options);
+    const output = {
+      role: "assistant",
+      content: [],
+      api: "azure-openai-responses",
+      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 = options?.apiKey;
+      if (!apiKey) {
+        throw new Error(`No API key for provider: ${model.provider}`);
+      }
+      const client = createClient(model, apiKey, options);
+      const grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(normalizedContext.messages), model.compat?.supportsOpenAIGrammarTools ?? false);
+      let params = buildParams(model, normalizedContext, options, deploymentName, 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, {
+        onProviderStreamEvent: options?.onProviderStreamEvent,
+        grammarToolInputProperties
+      });
+      if (options?.signal?.aborted) {
+        throw new Error("Request was aborted");
+      }
+      if (output.stopReason === "pending") {
+        throw new Error("Azure 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 = formatAzureOpenAIError(error);
+      stream2.push({ type: "error", reason: output.stopReason, error: output });
+      stream2.end();
+    }
+  })();
+  return stream2;
+}, "stream");
+var streamSimple = /* @__PURE__ */ __name((model, context, options) => {
+  const apiKey = options?.apiKey;
+  if (!apiKey) {
+    throw new Error(`No API key for provider: ${model.provider}`);
+  }
+  const base = {
+    ...buildBaseOptions(model, context, options, apiKey),
+    toolChoice: options?.toolChoice
+  };
+  const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : void 0;
+  const reasoningEffort = clampedReasoning === "off" ? void 0 : clampedReasoning;
+  return stream(model, context, {
+    ...base,
+    reasoningEffort
+  });
+}, "streamSimple");
+function createClient(model, apiKey, options) {
+  const headers = { "User-Agent": getPiUserAgent(), ...model.headers };
+  if (options?.headers) {
+    Object.assign(headers, options.headers);
+  }
+  const { baseUrl, apiVersion } = resolveAzureConfig(model, options);
+  return new AzureOpenAI({
+    apiKey,
+    apiVersion,
+    dangerouslyAllowBrowser: true,
+    fetch: options?.fetch,
+    defaultHeaders: headers,
+    baseURL: baseUrl
+  });
+}
+__name(createClient, "createClient");
+function buildParams(model, context, options, deploymentName, grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(context.messages), model.compat?.supportsOpenAIGrammarTools ?? false)) {
+  const supportsAdditionalTools = model.compat?.supportsAdditionalTools ?? false;
+  const supportsToolSearch = model.compat?.supportsToolSearch ?? false;
+  const transcriptTools = resolveTranscriptTools(context.messages, supportsAdditionalTools || supportsToolSearch);
+  const messages = convertResponsesMessages(model, context, AZURE_TOOL_CALL_PROVIDERS, {
+    grammarToolInputProperties,
+    supportsMidConvoSystemMessages: model.compat?.supportsMidConvoSystemMessages ?? false,
+    supportsAdditionalTools,
+    supportsToolSearch,
+    toolOptions: {
+      supportsStrictMode: model.compat?.supportsStrictMode ?? true,
+      supportsOpenAIGrammarTools: model.compat?.supportsOpenAIGrammarTools ?? false
+    }
+  });
+  const params = {
+    model: deploymentName,
+    input: messages,
+    stream: true,
+    prompt_cache_key: clampOpenAIPromptCacheKey(options?.sessionId),
+    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 (transcriptTools.requestTools.length > 0) {
+    params.tools = convertResponsesTools(transcriptTools.requestTools, {
+      supportsStrictMode: model.compat?.supportsStrictMode ?? true,
+      supportsOpenAIGrammarTools: model.compat?.supportsOpenAIGrammarTools ?? false
+    });
+  }
+  if (options?.toolChoice !== void 0) {
+    params.tool_choice = options.toolChoice;
+  }
+  const reasoningEffort = options?.reasoningEffort ?? (options?.reasoningSummary ? "medium" : void 0);
+  if (model.reasoning) {
+    if (reasoningEffort) {
+      const effort = options?.reasoningEffort ? model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort : reasoningEffort;
+      params.reasoning = {
+        effort,
+        summary: options?.reasoningSummary || "auto"
+      };
+      params.include = ["reasoning.encrypted_content"];
+    } else if (model.thinkingLevelMap?.off !== null) {
+      params.reasoning = {
+        effort: model.thinkingLevelMap?.off ?? "none"
+      };
+    }
+  }
+  const samplingParams = resolveSamplingParams(model, reasoningEffort ?? "off", options?.samplingParams);
+  if (samplingParams) {
+    Object.assign(params, samplingParams);
+  }
+  return params;
+}
+__name(buildParams, "buildParams");
+export {
+  stream,
+  streamSimple
+};