@rowan-agent/models 0.4.4

package/dist/providers/index.cjs

@@ -0,0 +1,1262 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/providers/index.ts
+var providers_exports = {};
+__export(providers_exports, {
+  ProviderError: () => ProviderError,
+  callOpenAICompletions: () => callOpenAICompletions,
+  createAnthropicStream: () => createAnthropicStream,
+  createOpenAICompletionsStream: () => createOpenAICompletionsStream,
+  createOpenAIResponsesStream: () => createOpenAIResponsesStream,
+  resolveAnthropicConfig: () => resolveAnthropicConfig,
+  resolveOpenAICompletionsConfig: () => resolveOpenAICompletionsConfig,
+  resolveOpenAIResponsesConfig: () => resolveOpenAIResponsesConfig,
+  streamAnthropic: () => streamAnthropic,
+  streamOpenAICompletions: () => streamOpenAICompletions,
+  streamOpenAIResponses: () => streamOpenAIResponses
+});
+module.exports = __toCommonJS(providers_exports);
+
+// src/providers/shared.ts
+var ProviderError = class extends Error {
+  code;
+  status;
+  retryable;
+  details;
+  constructor(input) {
+    super(input.message);
+    this.name = "ProviderError";
+    this.code = input.code;
+    this.status = input.status;
+    this.retryable = input.retryable ?? false;
+    this.details = input.details;
+  }
+};
+function defaultEnv() {
+  return process.env;
+}
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+function nonEmpty(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
+function requireValue(name, value, hint) {
+  const normalized = nonEmpty(value);
+  if (!normalized) {
+    throw new ProviderError({
+      code: "missing_config",
+      message: `Missing ${name}: ${hint}.`
+    });
+  }
+  return normalized;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asTrimmedString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function truncateString(value, maxLength = 4e3) {
+  return value.length > maxLength ? `${value.slice(0, maxLength)}...` : value;
+}
+function createRequestSignal(input) {
+  if (!input.signal && !input.timeoutMs) {
+    return { cleanup: () => void 0 };
+  }
+  const controller = new AbortController();
+  let timeout;
+  const abortFromParent = () => {
+    controller.abort(input.signal?.reason ?? new Error("Request aborted."));
+  };
+  if (input.signal?.aborted) {
+    abortFromParent();
+  } else {
+    input.signal?.addEventListener("abort", abortFromParent, { once: true });
+  }
+  if (input.timeoutMs) {
+    timeout = setTimeout(() => {
+      controller.abort(new Error(`Request timed out after ${input.timeoutMs}ms.`));
+    }, input.timeoutMs);
+  }
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      if (timeout) clearTimeout(timeout);
+      input.signal?.removeEventListener("abort", abortFromParent);
+    }
+  };
+}
+async function readErrorBody(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  try {
+    if (contentType.includes("application/json")) {
+      return await response.json();
+    }
+    return await response.text();
+  } catch {
+    return null;
+  }
+}
+function isRetryableStatus(status) {
+  return status === 408 || status === 409 || status === 429 || status >= 500;
+}
+function normalizeRequestError(error, signal) {
+  if (error instanceof ProviderError) return error;
+  if (signal?.aborted) {
+    return new ProviderError({
+      code: "request_aborted",
+      message: signal.reason instanceof Error ? signal.reason.message : "Request aborted.",
+      retryable: true
+    });
+  }
+  return new ProviderError({
+    code: "request_failed",
+    message: error instanceof Error ? error.message : "Request failed.",
+    retryable: true
+  });
+}
+var DEFAULT_MAX_RETRIES = 2;
+var DEFAULT_RETRY_DELAY_MS = 500;
+function normalizeRetryNumber(value, fallback) {
+  if (value === void 0) return fallback;
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+function shouldRetry(input) {
+  return input.error.retryable && input.attempts < input.maxRetries && !input.signal?.aborted;
+}
+async function waitForRetry(delayMs, signal) {
+  if (delayMs <= 0) return;
+  if (signal?.aborted) {
+    throw new ProviderError({
+      code: "request_aborted",
+      message: "Request aborted.",
+      retryable: true
+    });
+  }
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    }, delayMs);
+    const abort = () => {
+      clearTimeout(timeout);
+      reject(new ProviderError({
+        code: "request_aborted",
+        message: "Request aborted.",
+        retryable: true
+      }));
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+function normalizeUsage(usage) {
+  if (!usage) return void 0;
+  const inputTokens = asNumber(usage.prompt_tokens) ?? asNumber(usage.input_tokens);
+  const outputTokens = asNumber(usage.completion_tokens) ?? asNumber(usage.output_tokens);
+  const totalTokens = asNumber(usage.total_tokens);
+  if (inputTokens === void 0 && outputTokens === void 0 && totalTokens === void 0) {
+    return void 0;
+  }
+  return {
+    ...inputTokens !== void 0 ? { inputTokens } : {},
+    ...outputTokens !== void 0 ? { outputTokens } : {},
+    ...totalTokens !== void 0 ? { totalTokens } : {}
+  };
+}
+function summarizeRequestUsage(request) {
+  return { inputMessages: request.messages.length + (request.system ? 1 : 0) };
+}
+
+// src/sse.ts
+function flushSseEvent(state) {
+  if (!state.event && state.data.length === 0) {
+    return null;
+  }
+  const event = {
+    event: state.event,
+    data: state.data.join("\n")
+  };
+  state.event = null;
+  state.data = [];
+  return event;
+}
+function decodeSseLine(line, state) {
+  if (line === "") {
+    return flushSseEvent(state);
+  }
+  if (line.startsWith(":")) {
+    return null;
+  }
+  const delimiterIndex = line.indexOf(":");
+  const fieldName = delimiterIndex === -1 ? line : line.slice(0, delimiterIndex);
+  let value = delimiterIndex === -1 ? "" : line.slice(delimiterIndex + 1);
+  if (value.startsWith(" ")) {
+    value = value.slice(1);
+  }
+  if (fieldName === "event") {
+    state.event = value;
+  } else if (fieldName === "data") {
+    state.data.push(value);
+  }
+  return null;
+}
+function nextLineBreakIndex(text) {
+  const cr = text.indexOf("\r");
+  const lf = text.indexOf("\n");
+  if (cr === -1) return lf;
+  if (lf === -1) return cr;
+  return Math.min(cr, lf);
+}
+function consumeLine(text) {
+  const index = nextLineBreakIndex(text);
+  if (index === -1) return null;
+  let nextIndex = index + 1;
+  if (text[index] === "\r" && text[nextIndex] === "\n") {
+    nextIndex += 1;
+  }
+  return {
+    line: text.slice(0, index),
+    rest: text.slice(nextIndex)
+  };
+}
+async function* iterateSseMessages(body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  const state = { event: null, data: [] };
+  let buffer = "";
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        throw new Error("Request was aborted");
+      }
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let consumed2 = consumeLine(buffer);
+      while (consumed2) {
+        buffer = consumed2.rest;
+        const event = decodeSseLine(consumed2.line, state);
+        if (event) yield event;
+        consumed2 = consumeLine(buffer);
+      }
+    }
+    buffer += decoder.decode();
+    let consumed = consumeLine(buffer);
+    while (consumed) {
+      buffer = consumed.rest;
+      const event = decodeSseLine(consumed.line, state);
+      if (event) yield event;
+      consumed = consumeLine(buffer);
+    }
+    if (buffer.length > 0) {
+      const event = decodeSseLine(buffer, state);
+      if (event) yield event;
+    }
+    const trailingEvent = flushSseEvent(state);
+    if (trailingEvent) yield trailingEvent;
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/providers/openai-completions.ts
+function resolveOpenAICompletionsConfig(input = {}) {
+  const env = input.env ?? defaultEnv();
+  const baseUrl = nonEmpty(input.baseUrl) ?? nonEmpty(env.ROWAN_OPENAI_BASE_URL) ?? "https://api.openai.com/v1";
+  const apiKey = nonEmpty(input.apiKey) ?? nonEmpty(env.ROWAN_OPENAI_API_KEY);
+  const model = nonEmpty(input.model) ?? nonEmpty(env.ROWAN_MODEL);
+  return {
+    baseUrl: normalizeBaseUrl(baseUrl),
+    apiKey: requireValue("API key", apiKey, "set ROWAN_OPENAI_API_KEY or pass --api-key"),
+    model: requireValue("model", model, "set ROWAN_MODEL or pass --model"),
+    ...input.temperature !== void 0 ? { temperature: input.temperature } : {},
+    ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {},
+    ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {},
+    ...input.maxRetries !== void 0 ? { maxRetries: input.maxRetries } : {},
+    ...input.retryDelayMs !== void 0 ? { retryDelayMs: input.retryDelayMs } : {},
+    ...input.fetch ? { fetch: input.fetch } : {},
+    ...input.responseFormat !== void 0 ? { responseFormat: input.responseFormat } : {}
+  };
+}
+function providerErrorFromBody(body) {
+  if (typeof body === "string") {
+    const message2 = asTrimmedString(body);
+    return message2 ? { message: truncateString(message2) } : void 0;
+  }
+  if (!isRecord(body)) return void 0;
+  const error = body.error;
+  if (typeof error === "string") {
+    const message2 = asTrimmedString(error);
+    return message2 ? { message: message2 } : void 0;
+  }
+  const source = isRecord(error) ? error : body;
+  const message = asTrimmedString(source.message);
+  const code = asTrimmedString(source.code);
+  const type = asTrimmedString(source.type);
+  if (!message && !code && !type) return void 0;
+  return { ...message ? { message } : {}, ...code ? { code } : {}, ...type ? { type } : {} };
+}
+function normalizeHttpError(response, body, context) {
+  const providerError = providerErrorFromBody(body);
+  const providerMessage = asTrimmedString(providerError?.message);
+  const statusSummary = response.statusText ? `${response.status} ${response.statusText}` : String(response.status);
+  const message = providerMessage ? `Request failed (${statusSummary}): ${providerMessage}` : `Request failed with status ${statusSummary}.`;
+  return new ProviderError({
+    code: "http_error",
+    message,
+    status: response.status,
+    retryable: isRetryableStatus(response.status),
+    details: {
+      endpoint: context.endpoint,
+      model: context.model,
+      status: response.status,
+      ...providerError ? { providerError } : {}
+    }
+  });
+}
+function convertMessages(messages) {
+  const result = [];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        result.push({ role: "user", content: msg.content });
+      } else {
+        const parts = [];
+        for (const part of msg.content) {
+          if (part.type === "text") {
+            parts.push({ type: "text", text: part.text });
+          } else if (part.type === "image") {
+            parts.push({ type: "image_url", image_url: { url: `data:${part.mimeType};base64,${part.data}` } });
+          }
+        }
+        result.push({ role: "user", content: parts });
+      }
+    } else if (msg.role === "assistant") {
+      if (typeof msg.content === "string") {
+        result.push({ role: "assistant", content: msg.content });
+      } else {
+        const toolUseBlocks = msg.content.filter((p) => p.type === "tool_use");
+        const textBlocks = msg.content.filter((p) => p.type === "text");
+        const text = textBlocks.map((p) => p.text).join("") || null;
+        if (toolUseBlocks.length > 0) {
+          const toolCalls = toolUseBlocks.map((p) => ({
+            id: p.id,
+            type: "function",
+            function: {
+              name: p.name,
+              arguments: typeof p.input === "string" ? p.input : JSON.stringify(p.input)
+            }
+          }));
+          result.push({ role: "assistant", content: text, tool_calls: toolCalls });
+        } else {
+          result.push({ role: "assistant", content: text });
+        }
+      }
+    } else if (msg.role === "tool") {
+      if (typeof msg.content === "string") {
+        result.push({ role: "tool", content: msg.content, tool_call_id: "" });
+      } else {
+        for (const part of msg.content) {
+          if (part.type === "tool_result") {
+            result.push({ role: "tool", content: part.content, tool_call_id: part.toolUseId });
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+function convertTools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    function: { name: tool.name, description: tool.description, parameters: tool.parameters }
+  }));
+}
+function buildRequestBody(config, request, stream) {
+  const messages = convertMessages(request.messages);
+  if (request.system) {
+    messages.unshift({ role: "system", content: request.system });
+  }
+  const body = {
+    model: config.model,
+    messages,
+    stream
+  };
+  if (stream) {
+    body.stream_options = { include_usage: true };
+  }
+  if (request.temperature !== void 0 || config.temperature !== void 0) {
+    body.temperature = request.temperature ?? config.temperature ?? 0;
+  }
+  if (request.maxTokens ?? config.maxTokens) {
+    body.max_tokens = request.maxTokens ?? config.maxTokens;
+  }
+  if (request.tools && request.tools.length > 0) {
+    body.tools = convertTools(request.tools);
+  }
+  if (config.responseFormat) {
+    body.response_format = { type: "json_object" };
+  }
+  return body;
+}
+function mapFinishReason(reason) {
+  switch (reason) {
+    case null:
+    case void 0:
+      return "end_turn";
+    case "stop":
+      return "end_turn";
+    case "length":
+      return "max_tokens";
+    case "tool_calls":
+      return "tool_use";
+    case "content_filter":
+      return "error";
+    default:
+      return "unknown";
+  }
+}
+async function* streamChatCompletions(config, request, options = {}) {
+  const maxRetries = normalizeRetryNumber(config.maxRetries, DEFAULT_MAX_RETRIES);
+  const retryDelayMs = normalizeRetryNumber(config.retryDelayMs, DEFAULT_RETRY_DELAY_MS);
+  const body = buildRequestBody(config, request, true);
+  const fetchImpl = config.fetch ?? fetch;
+  const endpoint = `${normalizeBaseUrl(config.baseUrl)}/chat/completions`;
+  const requestUsage = summarizeRequestUsage(request);
+  let attempts = 0;
+  while (true) {
+    attempts += 1;
+    const { signal, cleanup } = createRequestSignal({ signal: options.signal, timeoutMs: config.timeoutMs });
+    try {
+      let rebuildPartial2 = function() {
+        partial.contentBlocks = [];
+        if (content) {
+          partial.contentBlocks.push({ type: "text", text: content });
+        }
+        for (const tc of toolCalls.values()) {
+          partial.contentBlocks.push({
+            type: "tool_call",
+            id: tc.id,
+            name: tc.name,
+            args: tc.arguments
+          });
+        }
+      };
+      var rebuildPartial = rebuildPartial2;
+      const response = await fetchImpl(endpoint, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${config.apiKey}` },
+        body: JSON.stringify(body),
+        signal
+      });
+      if (!response.ok) {
+        throw normalizeHttpError(response, await readErrorBody(response), { endpoint, model: config.model });
+      }
+      if (!response.body) {
+        throw new ProviderError({ code: "no_body", message: "Response body is null.", retryable: true });
+      }
+      yield { type: "model_requested", model: request.model, usage: { ...requestUsage } };
+      if (!response.headers.get("content-type")?.includes("text/event-stream")) {
+        const data = await response.json();
+        const choice = data.choices?.[0];
+        const message = choice?.message;
+        const content2 = message?.content ?? "";
+        const partial2 = {
+          role: "assistant",
+          contentBlocks: []
+        };
+        yield { type: "start", partial: { ...partial2, contentBlocks: [...partial2.contentBlocks] } };
+        if (content2) {
+          partial2.contentBlocks.push({ type: "text", text: content2 });
+          yield { type: "text_delta", text: content2, partial: { ...partial2, contentBlocks: [...partial2.contentBlocks] } };
+        }
+        const toolCallResults2 = [];
+        for (const [index, tc] of (message?.tool_calls ?? []).entries()) {
+          const id = tc.id ?? `call_${index}`;
+          const name = tc.function?.name ?? "";
+          const args = tc.function?.arguments ?? "";
+          partial2.contentBlocks.push({ type: "tool_call", id, name, args });
+          yield { type: "tool_call_start", id, name, partial: { ...partial2, contentBlocks: [...partial2.contentBlocks] } };
+          yield { type: "tool_call_end", id, name, arguments: args, partial: { ...partial2, contentBlocks: [...partial2.contentBlocks] } };
+          let parsedArgs = args;
+          try {
+            parsedArgs = JSON.parse(args);
+          } catch {
+          }
+          toolCallResults2.push({ id, name, arguments: parsedArgs });
+        }
+        const usage2 = normalizeUsage(data.usage);
+        yield {
+          type: "done",
+          response: {
+            content: content2,
+            stopReason: mapFinishReason(choice?.finish_reason),
+            ...toolCallResults2.length > 0 ? { toolCalls: toolCallResults2 } : {},
+            ...usage2 ? { usage: usage2 } : {}
+          }
+        };
+        return;
+      }
+      let content = "";
+      let finishReason = null;
+      let usage;
+      const toolCalls = /* @__PURE__ */ new Map();
+      const partial = {
+        role: "assistant",
+        contentBlocks: []
+      };
+      yield { type: "start", partial: { ...partial, contentBlocks: [...partial.contentBlocks] } };
+      for await (const sse of iterateSseMessages(response.body, signal)) {
+        if (sse.data === "[DONE]") break;
+        let chunk;
+        try {
+          chunk = JSON.parse(sse.data);
+        } catch {
+          continue;
+        }
+        if (chunk.usage) usage = normalizeUsage(chunk.usage);
+        const choice = chunk.choices?.[0];
+        if (!choice) continue;
+        const delta = choice.delta;
+        if (delta) {
+          if (delta.content) {
+            content += delta.content;
+            rebuildPartial2();
+            yield { type: "text_delta", text: delta.content, partial: { ...partial, contentBlocks: [...partial.contentBlocks] } };
+          }
+          if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              const existing = toolCalls.get(tc.index);
+              if (!existing) {
+                const newTc = { id: tc.id ?? "", name: tc.function?.name ?? "", arguments: tc.function?.arguments ?? "" };
+                toolCalls.set(tc.index, newTc);
+                if (tc.id || tc.function?.name) {
+                  rebuildPartial2();
+                  yield { type: "tool_call_start", id: newTc.id, name: newTc.name, partial: { ...partial, contentBlocks: [...partial.contentBlocks] } };
+                }
+                if (tc.function?.arguments) {
+                  yield { type: "tool_call_delta", id: newTc.id, arguments: tc.function.arguments, partial: { ...partial, contentBlocks: [...partial.contentBlocks] } };
+                }
+              } else {
+                if (tc.id) existing.id = tc.id;
+                if (tc.function?.name) existing.name = tc.function.name;
+                if (tc.function?.arguments) {
+                  existing.arguments += tc.function.arguments;
+                  rebuildPartial2();
+                  yield { type: "tool_call_delta", id: existing.id, arguments: tc.function.arguments, partial: { ...partial, contentBlocks: [...partial.contentBlocks] } };
+                }
+              }
+            }
+          }
+        }
+        if (choice.finish_reason) finishReason = choice.finish_reason;
+      }
+      for (const tc of toolCalls.values()) {
+        rebuildPartial2();
+        yield { type: "tool_call_end", id: tc.id, name: tc.name, arguments: tc.arguments, partial: { ...partial, contentBlocks: [...partial.contentBlocks] } };
+      }
+      const toolCallResults = [];
+      for (const tc of toolCalls.values()) {
+        let parsedArgs = tc.arguments;
+        try {
+          parsedArgs = JSON.parse(tc.arguments);
+        } catch {
+        }
+        toolCallResults.push({ id: tc.id, name: tc.name, arguments: parsedArgs });
+      }
+      yield {
+        type: "done",
+        response: {
+          content,
+          stopReason: mapFinishReason(finishReason),
+          ...toolCallResults.length > 0 ? { toolCalls: toolCallResults } : {},
+          ...usage ? { usage } : {}
+        }
+      };
+      return;
+    } catch (error) {
+      const requestError = normalizeRequestError(error, signal);
+      if (!shouldRetry({ error: requestError, attempts, maxRetries, signal: options.signal })) {
+        yield { type: "error", error: requestError };
+        yield { type: "done", response: { content: "", stopReason: "error" } };
+        return;
+      }
+      await waitForRetry(retryDelayMs * 2 ** (attempts - 1), options.signal);
+    } finally {
+      cleanup();
+    }
+  }
+}
+function createOpenAICompletionsStream(config) {
+  const normalizedConfig = { ...config, baseUrl: normalizeBaseUrl(config.baseUrl) };
+  return async function* openAICompletionsStream(request, options) {
+    yield* streamChatCompletions(normalizedConfig, request, options);
+  };
+}
+var streamOpenAICompletions = (model, request, options) => {
+  const config = resolveOpenAICompletionsConfig({
+    baseUrl: model.baseUrl,
+    model: model.id
+  });
+  return streamChatCompletions(config, request, options);
+};
+async function callOpenAICompletions(config, request, options = {}) {
+  const maxRetries = normalizeRetryNumber(config.maxRetries, DEFAULT_MAX_RETRIES);
+  const retryDelayMs = normalizeRetryNumber(config.retryDelayMs, DEFAULT_RETRY_DELAY_MS);
+  const body = buildRequestBody(config, request, false);
+  const fetchImpl = config.fetch ?? fetch;
+  const endpoint = `${normalizeBaseUrl(config.baseUrl)}/chat/completions`;
+  let attempts = 0;
+  while (true) {
+    attempts += 1;
+    const { signal, cleanup } = createRequestSignal({ signal: options.signal, timeoutMs: config.timeoutMs });
+    try {
+      const response = await fetchImpl(endpoint, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${config.apiKey}` },
+        body: JSON.stringify(body),
+        signal
+      });
+      if (!response.ok) {
+        throw normalizeHttpError(response, await readErrorBody(response), { endpoint, model: config.model });
+      }
+      const data = await response.json();
+      return { content: data.choices?.[0]?.message?.content ?? "", usage: normalizeUsage(data.usage) };
+    } catch (error) {
+      const requestError = normalizeRequestError(error, signal);
+      if (!shouldRetry({ error: requestError, attempts, maxRetries, signal: options.signal })) throw requestError;
+      await waitForRetry(retryDelayMs * 2 ** (attempts - 1), options.signal);
+    } finally {
+      cleanup();
+    }
+  }
+}
+
+// src/providers/openai-responses.ts
+function resolveOpenAIResponsesConfig(input = {}) {
+  const env = input.env ?? defaultEnv();
+  const baseUrl = nonEmpty(input.baseUrl) ?? nonEmpty(env.ROWAN_OPENAI_BASE_URL) ?? "https://api.openai.com/v1";
+  const apiKey = nonEmpty(input.apiKey) ?? nonEmpty(env.ROWAN_OPENAI_API_KEY);
+  const model = nonEmpty(input.model) ?? nonEmpty(env.ROWAN_MODEL);
+  return {
+    baseUrl: normalizeBaseUrl(baseUrl),
+    apiKey: requireValue("API key", apiKey, "set ROWAN_OPENAI_API_KEY or pass --api-key"),
+    model: requireValue("model", model, "set ROWAN_MODEL or pass --model"),
+    ...input.temperature !== void 0 ? { temperature: input.temperature } : {},
+    ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {},
+    ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {},
+    ...input.maxRetries !== void 0 ? { maxRetries: input.maxRetries } : {},
+    ...input.retryDelayMs !== void 0 ? { retryDelayMs: input.retryDelayMs } : {},
+    ...input.fetch ? { fetch: input.fetch } : {},
+    ...input.reasoningEffort !== void 0 ? { reasoningEffort: input.reasoningEffort } : {}
+  };
+}
+function normalizeHttpError2(response, body, context) {
+  let providerMessage;
+  if (isRecord(body) && isRecord(body.error)) {
+    providerMessage = asTrimmedString(body.error.message);
+  }
+  const statusSummary = response.statusText ? `${response.status} ${response.statusText}` : String(response.status);
+  const message = providerMessage ? `Request failed (${statusSummary}): ${providerMessage}` : `Request failed with status ${statusSummary}.`;
+  return new ProviderError({
+    code: "http_error",
+    message,
+    status: response.status,
+    retryable: isRetryableStatus(response.status),
+    details: { endpoint: context.endpoint, model: context.model, status: response.status, ...isRecord(body) ? { providerError: body.error } : {} }
+  });
+}
+function convertMessages2(messages) {
+  const result = [];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        result.push({ role: "user", content: msg.content });
+      } else {
+        const text = msg.content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+        if (text) result.push({ role: "user", content: text });
+      }
+    } else if (msg.role === "assistant") {
+      if (typeof msg.content === "string") {
+        result.push({ role: "assistant", content: msg.content });
+      } else {
+        const text = msg.content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+        if (text) result.push({ role: "assistant", content: text });
+        for (const part of msg.content) {
+          if (part.type === "tool_use") {
+            result.push({
+              type: "function_call",
+              id: part.id,
+              name: part.name,
+              arguments: typeof part.input === "string" ? part.input : JSON.stringify(part.input)
+            });
+          }
+        }
+      }
+    } else if (msg.role === "tool") {
+      if (typeof msg.content === "string") {
+        result.push({ type: "function_call_output", call_id: "", output: msg.content });
+      } else {
+        for (const part of msg.content) {
+          if (part.type === "tool_result") {
+            result.push({
+              type: "function_call_output",
+              call_id: part.toolUseId,
+              output: part.content
+            });
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+function convertTools2(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters,
+    strict: false
+  }));
+}
+function buildRequestBody2(config, request) {
+  const input = convertMessages2(request.messages);
+  const body = {
+    model: config.model,
+    input,
+    stream: true
+  };
+  if (request.system) {
+    body.instructions = request.system;
+  }
+  if (request.maxTokens ?? config.maxTokens) {
+    body.max_output_tokens = request.maxTokens ?? config.maxTokens;
+  }
+  if (request.tools && request.tools.length > 0) {
+    body.tools = convertTools2(request.tools);
+  }
+  if (config.reasoningEffort) {
+    body.reasoning = { effort: config.reasoningEffort, summary: "auto" };
+  }
+  return body;
+}
+function mapStopReason(reason) {
+  switch (reason) {
+    case "completed":
+      return "end_turn";
+    case "max_tokens":
+      return "max_tokens";
+    case "incomplete":
+      return "max_tokens";
+    default:
+      return "unknown";
+  }
+}
+async function* streamResponses(config, request, options = {}) {
+  const maxRetries = normalizeRetryNumber(config.maxRetries, DEFAULT_MAX_RETRIES);
+  const retryDelayMs = normalizeRetryNumber(config.retryDelayMs, DEFAULT_RETRY_DELAY_MS);
+  const body = buildRequestBody2(config, request);
+  const fetchImpl = config.fetch ?? fetch;
+  const endpoint = `${normalizeBaseUrl(config.baseUrl)}/responses`;
+  const requestUsage = summarizeRequestUsage(request);
+  let attempts = 0;
+  while (true) {
+    attempts += 1;
+    const { signal, cleanup } = createRequestSignal({ signal: options.signal, timeoutMs: config.timeoutMs });
+    try {
+      let rebuildPartial2 = function() {
+        partial.contentBlocks = [];
+        if (content) {
+          partial.contentBlocks.push({ type: "text", text: content });
+        }
+        for (const tc of toolCalls.values()) {
+          partial.contentBlocks.push({
+            type: "tool_call",
+            id: tc.id,
+            name: tc.name,
+            args: tc.arguments
+          });
+        }
+      };
+      var rebuildPartial = rebuildPartial2;
+      const response = await fetchImpl(endpoint, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${config.apiKey}` },
+        body: JSON.stringify(body),
+        signal
+      });
+      if (!response.ok) {
+        throw normalizeHttpError2(response, await readErrorBody(response), { endpoint, model: config.model });
+      }
+      if (!response.body) {
+        throw new ProviderError({ code: "no_body", message: "Response body is null.", retryable: true });
+      }
+      yield { type: "model_requested", model: request.model, usage: { ...requestUsage } };
+      let content = "";
+      let stopReason = null;
+      let usage;
+      const toolCalls = /* @__PURE__ */ new Map();
+      const partial = {
+        role: "assistant",
+        contentBlocks: []
+      };
+      yield { type: "start", partial: { ...partial, contentBlocks: [...partial.contentBlocks] } };
+      for await (const sse of iterateSseMessages(response.body, signal)) {
+        let event;
+        try {
+          event = JSON.parse(sse.data);
+        } catch {
+          continue;
+        }
+        switch (event.type) {
+          case "response.output_text.delta":
+            content += event.delta;
+            rebuildPartial2();
+            yield { type: "text_delta", text: event.delta, partial: { ...partial, contentBlocks: [...partial.contentBlocks] } };
+            break;
+          case "response.output_item.added":
+            if (event.item.type === "function_call") {
+              const tc = { id: event.item.id ?? "", name: event.item.name ?? "", arguments: "" };
+              toolCalls.set(event.output_index, tc);
+              rebuildPartial2();
+              yield { type: "tool_call_start", id: tc.id, name: tc.name, partial: { ...partial, contentBlocks: [...partial.contentBlocks] } };
+            }
+            break;
+          case "response.function_call_arguments.delta": {
+            const tc = toolCalls.get(event.output_index);
+            if (tc) {
+              tc.arguments += event.delta;
+              rebuildPartial2();
+              yield { type: "tool_call_delta", id: tc.id, arguments: event.delta, partial: { ...partial, contentBlocks: [...partial.contentBlocks] } };
+            }
+            break;
+          }
+          case "response.function_call_arguments.done": {
+            const tc = toolCalls.get(event.output_index);
+            if (tc) {
+              tc.arguments = event.arguments;
+            }
+            break;
+          }
+          case "response.output_item.done": {
+            if (event.item.type === "function_call") {
+              const tc = toolCalls.get(event.output_index);
+              if (tc) {
+                if (event.item.arguments) tc.arguments = event.item.arguments;
+                rebuildPartial2();
+                yield { type: "tool_call_end", id: tc.id, name: tc.name, arguments: tc.arguments, partial: { ...partial, contentBlocks: [...partial.contentBlocks] } };
+              }
+            }
+            break;
+          }
+          case "response.completed":
+            if (event.response.usage) {
+              usage = {
+                inputTokens: event.response.usage.input_tokens,
+                outputTokens: event.response.usage.output_tokens,
+                totalTokens: event.response.usage.total_tokens
+              };
+            }
+            stopReason = "completed";
+            break;
+          case "response.incomplete":
+            if (event.response.usage) {
+              usage = {
+                inputTokens: event.response.usage.input_tokens,
+                outputTokens: event.response.usage.output_tokens,
+                totalTokens: event.response.usage.total_tokens
+              };
+            }
+            stopReason = event.response.incomplete_details?.reason ?? "incomplete";
+            break;
+          case "error":
+            throw new ProviderError({
+              code: "stream_error",
+              message: event.error.message,
+              details: { type: event.error.type }
+            });
+        }
+      }
+      const toolCallResults = [];
+      for (const tc of toolCalls.values()) {
+        let parsedArgs = tc.arguments;
+        try {
+          parsedArgs = JSON.parse(tc.arguments);
+        } catch {
+        }
+        toolCallResults.push({ id: tc.id, name: tc.name, arguments: parsedArgs });
+      }
+      yield {
+        type: "done",
+        response: {
+          content,
+          stopReason: mapStopReason(stopReason),
+          ...toolCallResults.length > 0 ? { toolCalls: toolCallResults } : {},
+          ...usage ? { usage } : {}
+        }
+      };
+      return;
+    } catch (error) {
+      const requestError = normalizeRequestError(error, signal);
+      if (!shouldRetry({ error: requestError, attempts, maxRetries, signal: options.signal })) {
+        yield { type: "error", error: requestError };
+        yield { type: "done", response: { content: "", stopReason: "error" } };
+        return;
+      }
+      await waitForRetry(retryDelayMs * 2 ** (attempts - 1), options.signal);
+    } finally {
+      cleanup();
+    }
+  }
+}
+function createOpenAIResponsesStream(config) {
+  const normalizedConfig = { ...config, baseUrl: normalizeBaseUrl(config.baseUrl) };
+  return async function* openAIResponsesStream(request, options) {
+    yield* streamResponses(normalizedConfig, request, options);
+  };
+}
+var streamOpenAIResponses = (model, request, options) => {
+  const config = resolveOpenAIResponsesConfig({
+    baseUrl: model.baseUrl,
+    model: model.id
+  });
+  return streamResponses(config, request, options);
+};
+
+// src/providers/anthropic.ts
+var DEFAULT_MAX_TOKENS = 8192;
+function resolveAnthropicConfig(input = {}) {
+  const env = input.env ?? defaultEnv();
+  const baseUrl = nonEmpty(input.baseUrl) ?? nonEmpty(env.ROWAN_ANTHROPIC_BASE_URL) ?? "https://api.anthropic.com";
+  const apiKey = nonEmpty(input.apiKey) ?? nonEmpty(env.ROWAN_ANTHROPIC_API_KEY) ?? nonEmpty(env.ANTHROPIC_API_KEY);
+  const model = nonEmpty(input.model) ?? nonEmpty(env.ROWAN_MODEL);
+  return {
+    baseUrl: normalizeBaseUrl(baseUrl),
+    apiKey: requireValue("API key", apiKey, "set ROWAN_ANTHROPIC_API_KEY or pass --api-key"),
+    model: requireValue("model", model, "set ROWAN_MODEL or pass --model"),
+    ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {},
+    ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {},
+    ...input.maxRetries !== void 0 ? { maxRetries: input.maxRetries } : {},
+    ...input.retryDelayMs !== void 0 ? { retryDelayMs: input.retryDelayMs } : {},
+    ...input.fetch ? { fetch: input.fetch } : {},
+    ...input.thinking ? { thinking: input.thinking } : {}
+  };
+}
+function normalizeHttpError3(response, body) {
+  let providerMessage;
+  if (isRecord(body) && isRecord(body.error)) {
+    providerMessage = asTrimmedString(body.error.message);
+  }
+  const statusSummary = response.statusText ? `${response.status} ${response.statusText}` : String(response.status);
+  const message = providerMessage ? `Anthropic request failed (${statusSummary}): ${providerMessage}` : `Anthropic request failed with status ${statusSummary}.`;
+  return new ProviderError({
+    code: "http_error",
+    message,
+    status: response.status,
+    retryable: isRetryableStatus(response.status),
+    details: { status: response.status, ...isRecord(body) ? { providerError: body.error } : {} }
+  });
+}
+function convertContentParts(parts) {
+  const hasNonText = parts.some((p) => p.type !== "text");
+  if (!hasNonText) {
+    return parts.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+  }
+  const blocks = [];
+  for (const part of parts) {
+    if (part.type === "text") {
+      blocks.push({ type: "text", text: part.text });
+    } else if (part.type === "image") {
+      blocks.push({
+        type: "image",
+        source: { type: "base64", media_type: part.mimeType, data: part.data }
+      });
+    } else if (part.type === "tool_use") {
+      blocks.push({ type: "tool_use", id: part.id, name: part.name, input: part.input });
+    } else if (part.type === "tool_result") {
+      blocks.push({ type: "tool_result", tool_use_id: part.toolUseId, content: part.content, is_error: part.isError });
+    }
+  }
+  return blocks;
+}
+function convertMessages3(messages) {
+  const result = [];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        result.push({ role: "user", content: msg.content });
+      } else {
+        result.push({ role: "user", content: convertContentParts(msg.content) });
+      }
+    } else if (msg.role === "assistant") {
+      if (typeof msg.content === "string") {
+        result.push({ role: "assistant", content: msg.content });
+      } else {
+        const hasToolUse = msg.content.some((p) => p.type === "tool_use");
+        if (hasToolUse) {
+          result.push({ role: "assistant", content: convertContentParts(msg.content) });
+        } else {
+          const texts = msg.content.filter((p) => p.type === "text").map((p) => p.text);
+          result.push({ role: "assistant", content: texts.join("\n") });
+        }
+      }
+    } else if (msg.role === "tool") {
+      if (typeof msg.content === "string") {
+        result.push({ role: "user", content: msg.content });
+      } else {
+        result.push({ role: "user", content: convertContentParts(msg.content) });
+      }
+    }
+  }
+  return result;
+}
+function convertTools3(tools) {
+  return tools.map((tool) => {
+    const schema = tool.parameters ?? {};
+    return {
+      name: tool.name,
+      description: tool.description,
+      input_schema: {
+        type: "object",
+        properties: schema.properties ?? {},
+        required: schema.required ?? []
+      }
+    };
+  });
+}
+function buildRequestBody3(config, request) {
+  const messages = convertMessages3(request.messages);
+  const body = {
+    model: config.model,
+    messages,
+    max_tokens: request.maxTokens ?? config.maxTokens ?? DEFAULT_MAX_TOKENS,
+    stream: true
+  };
+  if (request.system) body.system = request.system;
+  if (request.temperature !== void 0) body.temperature = request.temperature;
+  if (request.tools && request.tools.length > 0) body.tools = convertTools3(request.tools);
+  if (config.thinking) {
+    body.thinking = { type: "enabled", budget_tokens: config.thinking.budgetTokens };
+  }
+  return body;
+}
+function mapStopReason2(reason) {
+  switch (reason) {
+    case "end_turn":
+      return "end_turn";
+    case "max_tokens":
+      return "max_tokens";
+    case "tool_use":
+      return "tool_use";
+    case "stop_sequence":
+      return "stop";
+    default:
+      return "unknown";
+  }
+}
+var MESSAGE_EVENTS = /* @__PURE__ */ new Set([
+  "message_start",
+  "message_delta",
+  "message_stop",
+  "content_block_start",
+  "content_block_delta",
+  "content_block_stop"
+]);
+async function* streamAnthropicMessages(config, request, options = {}) {
+  const maxRetries = normalizeRetryNumber(config.maxRetries, DEFAULT_MAX_RETRIES);
+  const retryDelayMs = normalizeRetryNumber(config.retryDelayMs, DEFAULT_RETRY_DELAY_MS);
+  const body = buildRequestBody3(config, request);
+  const fetchImpl = config.fetch ?? fetch;
+  const endpoint = `${normalizeBaseUrl(config.baseUrl)}/v1/messages`;
+  const requestUsage = summarizeRequestUsage(request);
+  let attempts = 0;
+  while (true) {
+    attempts += 1;
+    const { signal, cleanup } = createRequestSignal({ signal: options.signal, timeoutMs: config.timeoutMs });
+    try {
+      let rebuildPartial2 = function() {
+        partial.contentBlocks = [];
+        if (thinking) {
+          partial.contentBlocks.push({ type: "thinking", thinking });
+        }
+        if (content) {
+          partial.contentBlocks.push({ type: "text", text: content });
+        }
+        for (const tc of toolCalls.values()) {
+          partial.contentBlocks.push({
+            type: "tool_call",
+            id: tc.id,
+            name: tc.name,
+            args: tc.arguments
+          });
+        }
+      };
+      var rebuildPartial = rebuildPartial2;
+      const response = await fetchImpl(endpoint, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-api-key": config.apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify(body),
+        signal
+      });
+      if (!response.ok) throw normalizeHttpError3(response, await readErrorBody(response));
+      if (!response.body) {
+        throw new ProviderError({ code: "no_body", message: "Response body is null.", retryable: true });
+      }
+      yield { type: "model_requested", model: request.model, usage: { ...requestUsage } };
+      let content = "";
+      let thinking = "";
+      let stopReason = null;
+      let inputTokens = 0;
+      let outputTokens = 0;
+      const toolCalls = /* @__PURE__ */ new Map();
+      const blockTypes = /* @__PURE__ */ new Map();
+      const partial = {
+        role: "assistant",
+        contentBlocks: []
+      };
+      for await (const sse of iterateSseMessages(response.body, signal)) {
+        if (!sse.event || !MESSAGE_EVENTS.has(sse.event)) continue;
+        let event;
+        try {
+          event = JSON.parse(sse.data);
+        } catch {
+          continue;
+        }
+        switch (event.type) {
+          case "message_start":
+            inputTokens = event.message.usage.input_tokens;
+            outputTokens = event.message.usage.output_tokens;
+            break;
+          case "content_block_start":
+            blockTypes.set(event.index, event.content_block.type);
+            if (event.content_block.type === "tool_use") {
+              const tc = { id: event.content_block.id ?? "", name: event.content_block.name ?? "", arguments: "" };
+              toolCalls.set(event.index, tc);
+              rebuildPartial2();
+              yield { type: "tool_call_start", id: tc.id, name: tc.name, partial: { ...partial, contentBlocks: [...partial.contentBlocks] } };
+            }
+            break;
+          case "content_block_delta":
+            if (event.delta.type === "text_delta") {
+              content += event.delta.text;
+              rebuildPartial2();
+              yield { type: "text_delta", text: event.delta.text, partial: { ...partial, contentBlocks: [...partial.contentBlocks] } };
+            } else if (event.delta.type === "thinking_delta") {
+              thinking += event.delta.thinking;
+              rebuildPartial2();
+              yield { type: "thinking_delta", thinking: event.delta.thinking, partial: { ...partial, contentBlocks: [...partial.contentBlocks] } };
+            } else if (event.delta.type === "input_json_delta") {
+              const tc = toolCalls.get(event.index);
+              if (tc) {
+                tc.arguments += event.delta.partial_json;
+                rebuildPartial2();
+                yield { type: "tool_call_delta", id: tc.id, arguments: event.delta.partial_json, partial: { ...partial, contentBlocks: [...partial.contentBlocks] } };
+              }
+            }
+            break;
+          case "content_block_stop": {
+            if (blockTypes.get(event.index) === "tool_use") {
+              const tc = toolCalls.get(event.index);
+              if (tc) {
+                rebuildPartial2();
+                yield { type: "tool_call_end", id: tc.id, name: tc.name, arguments: tc.arguments, partial: { ...partial, contentBlocks: [...partial.contentBlocks] } };
+              }
+            }
+            break;
+          }
+          case "message_delta":
+            if (event.delta.stop_reason) stopReason = event.delta.stop_reason;
+            outputTokens = event.usage.output_tokens;
+            break;
+          case "message_stop":
+            break;
+        }
+      }
+      const toolCallResults = [];
+      for (const tc of toolCalls.values()) {
+        let parsedArgs = tc.arguments;
+        try {
+          parsedArgs = JSON.parse(tc.arguments);
+        } catch {
+        }
+        toolCallResults.push({ id: tc.id, name: tc.name, arguments: parsedArgs });
+      }
+      const usage = { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens };
+      yield {
+        type: "done",
+        response: {
+          content,
+          ...thinking ? { thinking } : {},
+          stopReason: mapStopReason2(stopReason ?? "end_turn"),
+          ...toolCallResults.length > 0 ? { toolCalls: toolCallResults } : {},
+          usage
+        }
+      };
+      return;
+    } catch (error) {
+      const requestError = normalizeRequestError(error, signal);
+      if (!shouldRetry({ error: requestError, attempts, maxRetries, signal: options.signal })) {
+        yield { type: "error", error: requestError };
+        yield { type: "done", response: { content: "", stopReason: "error" } };
+        return;
+      }
+      await waitForRetry(retryDelayMs * 2 ** (attempts - 1), options.signal);
+    } finally {
+      cleanup();
+    }
+  }
+}
+function createAnthropicStream(config) {
+  const normalizedConfig = { ...config, baseUrl: normalizeBaseUrl(config.baseUrl) };
+  return async function* anthropicStream(request, options) {
+    yield* streamAnthropicMessages(normalizedConfig, request, options);
+  };
+}
+var streamAnthropic = (model, request, options) => {
+  const config = resolveAnthropicConfig({
+    baseUrl: model.baseUrl,
+    model: model.id
+  });
+  return streamAnthropicMessages(config, request, options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProviderError,
+  callOpenAICompletions,
+  createAnthropicStream,
+  createOpenAICompletionsStream,
+  createOpenAIResponsesStream,
+  resolveAnthropicConfig,
+  resolveOpenAICompletionsConfig,
+  resolveOpenAIResponsesConfig,
+  streamAnthropic,
+  streamOpenAICompletions,
+  streamOpenAIResponses
+});