@alma-harness/providers 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,10 +1,57 @@
 // src/anthropic/client.ts
 import Anthropic from "@anthropic-ai/sdk";
 
+// src/errors.ts
+import { ProviderError } from "@alma-harness/core";
+var CONTEXT_WINDOW = /context_length_exceeded|prompt is too long|context window|maximum context length|too many tokens|exceeds the context|input length/i;
+var OVERLOADED = /overloaded|too many requests|capacity|server_busy/i;
+function hintsOf(e) {
+  const nested = typeof e.error === "object" && e.error !== null ? e.error : {};
+  const inner = typeof nested.error === "object" && nested.error !== null ? nested.error : {};
+  return [e.code, e.type, nested.code, nested.type, inner.code, inner.type, inner.message].filter((h) => typeof h === "string").join(" ").toLowerCase();
+}
+function toProviderError(provider, err) {
+  if (err instanceof ProviderError) return err;
+  const e = typeof err === "object" && err !== null ? err : {};
+  const own = typeof e.name === "string" && e.name !== "Error" ? e.name : "";
+  const name = own !== "" ? own : err?.constructor?.name ?? "";
+  if (name === "APIUserAbortError" || name === "AbortError") return err;
+  const message = err instanceof Error ? err.message : String(err);
+  const status = typeof e.status === "number" ? e.status : void 0;
+  const kind = classifyFailure(name, status, `${hintsOf(e)} ${message.toLowerCase()}`);
+  return new ProviderError(provider, kind, message, { ...status !== void 0 ? { status } : {}, cause: err });
+}
+function classifyFailure(name, status, hints) {
+  if (status === 429 || /rate_limit/.test(hints)) return hints.includes("insufficient_quota") ? "rejected" : "rate_limited";
+  if (status === 529 || status === 503 || (status === void 0 || status >= 500) && OVERLOADED.test(hints)) return "overloaded";
+  if (status !== void 0 && status >= 500) return "unavailable";
+  if ((status === void 0 || status === 400) && CONTEXT_WINDOW.test(hints)) return "context_window";
+  if (status !== void 0 && status >= 400) return "rejected";
+  if (/connection|timeout|timed out|fetch|network|socket|econn|enotfound|server_error|internal|unavailable/i.test(`${name} ${hints}`)) {
+    return "unavailable";
+  }
+  return "provider_drift";
+}
+
 // src/anthropic/translate.ts
-var AnthropicTranslationError = class extends Error {
-  constructor(message) {
-    super(message);
+import {
+  ProviderError as ProviderError2
+} from "@alma-harness/core";
+
+// src/arguments.ts
+function parseToolArguments(json) {
+  if (json === "") return { input: {} };
+  try {
+    return { input: JSON.parse(json) };
+  } catch {
+    return { input: {}, malformed: json };
+  }
+}
+
+// src/anthropic/translate.ts
+var AnthropicTranslationError = class extends ProviderError2 {
+  constructor(message, kind = "rejected") {
+    super("anthropic", kind, message);
     this.name = "AnthropicTranslationError";
   }
 };
@@ -14,17 +61,50 @@ function toAnthropicParams(req) {
       `AnthropicModelClient received a request for provider ${JSON.stringify(req.model.provider)}`
     );
   }
+  const reasoning = req.reasoning;
+  const replay = reasoning !== void 0 && reasoning.effort !== "none";
   const params = {
     model: req.model.id,
     max_tokens: req.maxTokens,
     stream: true,
     system: toSystem(req.system),
-    messages: req.messages.map(toMessageParam)
+    messages: req.messages.flatMap((m) => toMessageParams(m, replay, declaredKinds(req)))
   };
-  if (req.tools.length > 0) params.tools = req.tools.map(toTool);
+  if (reasoning !== void 0) {
+    if (reasoning.effort === "none") {
+      params.thinking = { type: "disabled" };
+    } else {
+      params.thinking = { type: "adaptive" };
+      params.output_config = { effort: toAnthropicEffort(reasoning.effort) };
+    }
+  }
+  switch (req.serviceTier) {
+    case void 0:
+    case "standard":
+      break;
+    case "priority":
+      params.service_tier = "auto";
+      break;
+    default:
+      throw new AnthropicTranslationError(
+        `the Anthropic Messages API cannot serve the ${req.serviceTier} tier on a streaming request`
+      );
+  }
+  const tools = [...req.tools.map(toTool), ...(req.providerTools ?? []).map(toServerTool)];
+  if (tools.length > 0) params.tools = tools;
   markConversationTail(params.messages);
   return params;
 }
+function toServerTool(spec) {
+  const tool = { type: "web_search_20250305", name: "web_search" };
+  if (spec.maxUses !== void 0) tool.max_uses = spec.maxUses;
+  if (spec.allowedDomains !== void 0) tool.allowed_domains = [...spec.allowedDomains];
+  if (spec.blockedDomains !== void 0) tool.blocked_domains = [...spec.blockedDomains];
+  return tool;
+}
+function toAnthropicEffort(effort) {
+  return effort === "minimal" ? "low" : effort;
+}
 function markConversationTail(messages) {
   const last = messages.at(-1);
   if (!last || typeof last.content === "string") return;
@@ -42,14 +122,19 @@ function toSystem(blocks) {
     return param;
   });
 }
-function toMessageParam(msg) {
+function declaredKinds(req) {
+  return new Set((req.providerTools ?? []).map((t) => t.kind));
+}
+function toMessageParams(msg, replayReasoning, declared) {
   switch (msg.role) {
     case "user":
-      return { role: "user", content: msg.blocks.map(toUserBlock) };
-    case "assistant":
-      return { role: "assistant", content: msg.blocks.map(toAssistantBlock) };
+      return [{ role: "user", content: msg.blocks.map(toUserBlock) }];
+    case "assistant": {
+      const content = msg.blocks.flatMap((b) => toAssistantBlocks(b, replayReasoning, declared));
+      return content.length === 0 ? [] : [{ role: "assistant", content }];
+    }
     case "tool":
-      return { role: "user", content: msg.blocks.map(toToolResultBlock) };
+      return [{ role: "user", content: msg.blocks.map(toToolResultBlock) }];
   }
 }
 function toUserBlock(block) {
@@ -69,18 +154,41 @@ function toUserBlock(block) {
       throw new AnthropicTranslationError(`block type ${JSON.stringify(block.type)} is not valid in a user message`);
   }
 }
-function toAssistantBlock(block) {
+function toAssistantBlocks(block, replayReasoning, declared) {
   switch (block.type) {
     case "text":
-      return { type: "text", text: block.text };
+      return [{ type: "text", text: block.text }];
     case "tool_call":
-      return { type: "tool_use", id: block.id, name: block.name, input: block.input };
+      return [{ type: "tool_use", id: block.id, name: block.name, input: block.input }];
+    case "reasoning":
+      return block.provider === "anthropic" && replayReasoning ? [toThinkingParam(block)] : [];
+    case "provider_tool_call":
+      return block.provider === "anthropic" && declared.has(block.name) ? [{ type: "server_tool_use", id: block.id, name: block.name, input: block.input }] : [];
+    case "provider_tool_result":
+      return block.provider === "anthropic" && declared.has(block.name) ? [toWebSearchResultParam(block)] : [];
     default:
       throw new AnthropicTranslationError(
         `block type ${JSON.stringify(block.type)} is not valid in an assistant message`
       );
   }
 }
+function toWebSearchResultParam(block) {
+  const opaque = block.opaque;
+  if (opaque?.content === void 0) {
+    throw new AnthropicTranslationError("an Anthropic web search result carries no replayable content");
+  }
+  return { type: "web_search_tool_result", tool_use_id: block.callId, content: opaque.content };
+}
+function toThinkingParam(block) {
+  const opaque = block.opaque;
+  if (typeof opaque?.redacted === "string") {
+    return { type: "redacted_thinking", data: opaque.redacted };
+  }
+  if (typeof opaque?.signature === "string") {
+    return { type: "thinking", thinking: block.text ?? "", signature: opaque.signature };
+  }
+  throw new AnthropicTranslationError("an Anthropic reasoning block carries neither a signature nor redacted data");
+}
 function toToolResultBlock(block) {
   if (block.type !== "tool_result") {
     throw new AnthropicTranslationError(
@@ -109,6 +217,9 @@ async function* translateStream(events) {
   const usage = { inputTokens: 0, outputTokens: 0 };
   let stopReason = null;
   const pendingTools = /* @__PURE__ */ new Map();
+  const pendingThinking = /* @__PURE__ */ new Map();
+  const pendingRedacted = /* @__PURE__ */ new Map();
+  const pendingServer = /* @__PURE__ */ new Map();
   for await (const event of events) {
     switch (event.type) {
       case "message_start": {
@@ -118,6 +229,10 @@ async function* translateStream(events) {
         if (u.cache_creation_input_tokens != null) {
           usage.cacheWriteInputTokens = u.cache_creation_input_tokens;
         }
+        if (u.server_tool_use?.web_search_requests) usage.webSearchRequests = u.server_tool_use.web_search_requests;
+        if (u.service_tier === "standard" || u.service_tier === "priority" || u.service_tier === "batch") {
+          usage.serviceTier = u.service_tier;
+        }
         break;
       }
       case "content_block_start":
@@ -127,25 +242,58 @@ async function* translateStream(events) {
             name: event.content_block.name,
             json: ""
           });
+        } else if (event.content_block.type === "thinking") {
+          pendingThinking.set(event.index, { text: event.content_block.thinking, signature: event.content_block.signature });
+        } else if (event.content_block.type === "redacted_thinking") {
+          pendingRedacted.set(event.index, event.content_block.data);
+        } else if (event.content_block.type === "server_tool_use") {
+          if (event.content_block.name !== "web_search") {
+            throw new AnthropicTranslationError(`Unmapped Anthropic server tool ${JSON.stringify(event.content_block.name)} \u2014 provider drift?`, "provider_drift");
+          }
+          pendingServer.set(event.index, { id: event.content_block.id, name: "web_search", json: "" });
+        } else if (event.content_block.type === "web_search_tool_result") {
+          yield { type: "provider_tool_result", block: toProviderToolResult(event.content_block) };
         }
         break;
       case "content_block_delta":
         if (event.delta.type === "text_delta") {
           yield { type: "text_delta", text: event.delta.text };
         } else if (event.delta.type === "input_json_delta") {
-          const pending = pendingTools.get(event.index);
+          const pending = pendingTools.get(event.index) ?? pendingServer.get(event.index);
           if (pending) pending.json += event.delta.partial_json;
+        } else if (event.delta.type === "thinking_delta") {
+          const pending = pendingThinking.get(event.index);
+          if (pending) pending.text += event.delta.thinking;
+        } else if (event.delta.type === "signature_delta") {
+          const pending = pendingThinking.get(event.index);
+          if (pending) pending.signature = event.delta.signature;
         }
         break;
       case "content_block_stop": {
         const pending = pendingTools.get(event.index);
         if (pending) {
           pendingTools.delete(event.index);
+          yield { type: "tool_call", id: pending.id, name: pending.name, ...parseToolArguments(pending.json) };
+        }
+        const thinking = pendingThinking.get(event.index);
+        if (thinking) {
+          pendingThinking.delete(event.index);
+          yield {
+            type: "reasoning",
+            block: { type: "reasoning", provider: "anthropic", text: thinking.text, opaque: { signature: thinking.signature } }
+          };
+        }
+        const redacted = pendingRedacted.get(event.index);
+        if (redacted !== void 0) {
+          pendingRedacted.delete(event.index);
+          yield { type: "reasoning", block: { type: "reasoning", provider: "anthropic", opaque: { redacted } } };
+        }
+        const server = pendingServer.get(event.index);
+        if (server) {
+          pendingServer.delete(event.index);
           yield {
-            type: "tool_call",
-            id: pending.id,
-            name: pending.name,
-            input: pending.json === "" ? {} : JSON.parse(pending.json)
+            type: "provider_tool_call",
+            block: { type: "provider_tool_call", id: server.id, name: server.name, provider: "anthropic", input: parseToolArguments(server.json).input }
           };
         }
         break;
@@ -153,6 +301,7 @@ async function* translateStream(events) {
       case "message_delta":
         if (event.delta.stop_reason != null) stopReason = event.delta.stop_reason;
         usage.outputTokens = event.usage.output_tokens;
+        if (event.usage.server_tool_use?.web_search_requests) usage.webSearchRequests = event.usage.server_tool_use.web_search_requests;
         break;
       case "message_stop":
         yield { type: "usage", usage: { ...usage } };
@@ -161,6 +310,26 @@ async function* translateStream(events) {
     }
   }
 }
+function toProviderToolResult(block) {
+  const result = {
+    type: "provider_tool_result",
+    callId: block.tool_use_id,
+    name: "web_search",
+    provider: "anthropic",
+    results: [],
+    opaque: { content: block.content }
+  };
+  if (Array.isArray(block.content)) {
+    result.results = block.content.map((r) => ({
+      url: r.url,
+      ...r.title !== void 0 ? { title: r.title } : {},
+      ...r.page_age != null ? { pageAge: r.page_age } : {}
+    }));
+  } else {
+    result.error = block.content.error_code;
+  }
+  return result;
+}
 function mapStopReason(reason) {
   switch (reason) {
     case "end_turn":
@@ -174,9 +343,12 @@ function mapStopReason(reason) {
       return "refusal";
     case "model_context_window_exceeded":
       return "context_window_exceeded";
+    case "pause_turn":
+      return "pause";
     default:
       throw new AnthropicTranslationError(
-        `Unmapped Anthropic stop_reason ${JSON.stringify(reason)} \u2014 provider drift?`
+        `Unmapped Anthropic stop_reason ${JSON.stringify(reason)} \u2014 provider drift?`,
+        "provider_drift"
       );
   }
 }
@@ -195,11 +367,101 @@ var AnthropicModelClient = class {
     return translateStream(this.#rawEvents(params, opts?.signal));
   }
   async *#rawEvents(params, signal) {
-    const stream = await this.#client.messages.create(
-      params,
-      signal !== void 0 ? { signal } : void 0
-    );
-    for await (const event of stream) yield event;
+    try {
+      const stream = await this.#client.messages.create(
+        params,
+        signal !== void 0 ? { signal } : void 0
+      );
+      for await (const event of stream) yield event;
+    } catch (err) {
+      throw toProviderError("anthropic", err);
+    }
+  }
+};
+
+// src/anthropic/jobs.ts
+import Anthropic2 from "@anthropic-ai/sdk";
+function translateMessage(message) {
+  const blocks = [];
+  for (const block of message.content) {
+    switch (block.type) {
+      case "text":
+        blocks.push({ type: "text", text: block.text });
+        break;
+      case "tool_use":
+        blocks.push({ type: "tool_call", id: block.id, name: block.name, input: block.input });
+        break;
+      case "thinking":
+        blocks.push({ type: "reasoning", provider: "anthropic", text: block.thinking, opaque: { signature: block.signature } });
+        break;
+      case "redacted_thinking":
+        blocks.push({ type: "reasoning", provider: "anthropic", opaque: { redacted: block.data } });
+        break;
+      default:
+        throw new AnthropicTranslationError(`Unmapped Anthropic content block ${JSON.stringify(block.type)} \u2014 provider drift?`, "provider_drift");
+    }
+  }
+  const u = message.usage;
+  const usage = { inputTokens: u.input_tokens, outputTokens: u.output_tokens };
+  if (u.cache_read_input_tokens != null) usage.cacheReadInputTokens = u.cache_read_input_tokens;
+  if (u.cache_creation_input_tokens != null) usage.cacheWriteInputTokens = u.cache_creation_input_tokens;
+  if (u.service_tier === "standard" || u.service_tier === "priority" || u.service_tier === "batch") {
+    usage.serviceTier = u.service_tier;
+  }
+  return { blocks, usage, stop: mapStopReason(message.stop_reason) };
+}
+var AnthropicJobClient = class {
+  #client;
+  constructor(opts = {}) {
+    const init = {};
+    if (opts.apiKey !== void 0) init.apiKey = opts.apiKey;
+    if (opts.baseURL !== void 0) init.baseURL = opts.baseURL;
+    this.#client = new Anthropic2(init);
+  }
+  async submit(items) {
+    const first = items[0];
+    if (!first) throw new AnthropicTranslationError("a batch needs at least one item");
+    const requests = items.map((item) => {
+      const { serviceTier: _tier, ...req } = item.request;
+      void _tier;
+      const { stream: _stream, ...params } = toAnthropicParams(req);
+      void _stream;
+      return { custom_id: item.id, params };
+    });
+    const batch = await this.#client.messages.batches.create({ requests });
+    return { provider: "anthropic", id: batch.id, model: first.request.model };
+  }
+  async status(handle) {
+    const batch = await this.#client.messages.batches.retrieve(handle.id);
+    const c = batch.request_counts;
+    const total = c.processing + c.succeeded + c.errored + c.canceled + c.expired;
+    const status = batch.processing_status === "canceling" ? "cancelled" : batch.processing_status === "in_progress" ? "running" : c.canceled === total && total > 0 ? "cancelled" : c.expired === total && total > 0 ? "expired" : "done";
+    return { status, counts: { total, done: c.succeeded, failed: c.errored + c.canceled + c.expired } };
+  }
+  async *results(handle) {
+    const decoder = await this.#client.messages.batches.results(handle.id);
+    for await (const entry of decoder) {
+      const { custom_id: id, result } = entry;
+      switch (result.type) {
+        case "succeeded":
+          yield { id, outcome: "succeeded", output: translateMessage(result.message) };
+          break;
+        case "errored": {
+          const error = result.error?.error?.message;
+          yield { id, outcome: "errored", ...error !== void 0 ? { error } : {} };
+          break;
+        }
+        case "canceled":
+          yield { id, outcome: "cancelled" };
+          break;
+        case "expired":
+          yield { id, outcome: "expired" };
+          break;
+      }
+    }
+  }
+  async cancel(handle) {
+    await this.#client.messages.batches.cancel(handle.id);
   }
 };
 
@@ -207,9 +469,12 @@ var AnthropicModelClient = class {
 import OpenAI from "openai";
 
 // src/openai/translate.ts
-var OpenAITranslationError = class extends Error {
-  constructor(message) {
-    super(message);
+import {
+  ProviderError as ProviderError3
+} from "@alma-harness/core";
+var OpenAITranslationError = class extends ProviderError3 {
+  constructor(message, kind = "rejected") {
+    super("openai", kind, message);
     this.name = "OpenAITranslationError";
   }
 };
@@ -219,6 +484,8 @@ function toOpenAIParams(req) {
       `OpenAIModelClient received a request for provider ${JSON.stringify(req.model.provider)}`
     );
   }
+  const reasoning = req.reasoning;
+  const replay = reasoning !== void 0 && reasoning.effort !== "none";
   const params = {
     model: req.model.id,
     max_output_tokens: req.maxTokens,
@@ -226,22 +493,49 @@ function toOpenAIParams(req) {
     // Privacy-first (§3, §10): the Responses API stores responses server-side
     // by default; the harness never leaves conversation state at the provider.
     store: false,
-    input: req.messages.flatMap(toInputItems)
+    input: req.messages.flatMap((m) => toInputItems(m, replay, new Set((req.providerTools ?? []).map((t) => t.kind))))
   };
+  if (reasoning !== void 0) {
+    params.reasoning = replay ? { effort: reasoning.effort, summary: "auto" } : { effort: "none" };
+    if (replay) params.include = ["reasoning.encrypted_content"];
+  }
+  switch (req.serviceTier) {
+    case void 0:
+    case "standard":
+      break;
+    case "flex":
+    case "priority":
+      params.service_tier = req.serviceTier;
+      break;
+    default:
+      throw new OpenAITranslationError(
+        `the OpenAI Responses API cannot serve the ${req.serviceTier} tier on a streaming request`
+      );
+  }
   const instructions = toInstructions(req.system);
   if (instructions !== "") params.instructions = instructions;
-  if (req.tools.length > 0) params.tools = req.tools.map(toTool2);
+  const tools = [...req.tools.map(toTool2), ...(req.providerTools ?? []).map(toWebSearchTool)];
+  if (tools.length > 0) params.tools = tools;
+  if ((req.providerTools ?? []).length > 0) params.include = [...params.include ?? [], "web_search_call.action.sources"];
   return params;
 }
+function toWebSearchTool(spec) {
+  if (spec.blockedDomains !== void 0) {
+    throw new OpenAITranslationError("the OpenAI web search has no blocked-domains form \u2014 refusing rather than searching them");
+  }
+  const tool = { type: "web_search" };
+  if (spec.allowedDomains !== void 0) tool.filters = { allowed_domains: [...spec.allowedDomains] };
+  return tool;
+}
 function toInstructions(blocks) {
   return blocks.map((b) => b.text).join("\n\n");
 }
-function toInputItems(msg) {
+function toInputItems(msg, replayReasoning, declared) {
   switch (msg.role) {
     case "user":
       return [{ role: "user", content: msg.blocks.map(toUserContentPart) }];
     case "assistant":
-      return msg.blocks.map(toAssistantItem);
+      return msg.blocks.flatMap((b) => toAssistantItems(b, replayReasoning, declared));
     case "tool":
       return msg.blocks.map(toFunctionCallOutput);
   }
@@ -263,23 +557,50 @@ function toUserContentPart(block) {
       );
   }
 }
-function toAssistantItem(block) {
+function toAssistantItems(block, replayReasoning, declared) {
   switch (block.type) {
     case "text":
-      return { role: "assistant", content: block.text };
+      return [{ role: "assistant", content: block.text }];
     case "tool_call":
-      return {
-        type: "function_call",
-        call_id: block.id,
-        name: block.name,
-        arguments: JSON.stringify(block.input)
-      };
+      return [
+        {
+          type: "function_call",
+          call_id: block.id,
+          name: block.name,
+          arguments: JSON.stringify(block.input)
+        }
+      ];
+    case "reasoning":
+      return block.provider === "openai" && replayReasoning ? [toReasoningItem(block)] : [];
+    case "provider_tool_call":
+      return [];
+    case "provider_tool_result":
+      return block.provider === "openai" && declared.has(block.name) ? [toWebSearchItem(block)] : [];
     default:
       throw new OpenAITranslationError(
         `block type ${JSON.stringify(block.type)} is not valid in an assistant message`
       );
   }
 }
+function toWebSearchItem(block) {
+  const opaque = block.opaque;
+  if (opaque?.type !== "web_search_call") {
+    throw new OpenAITranslationError("an OpenAI web search result carries no replayable item");
+  }
+  return opaque;
+}
+function toReasoningItem(block) {
+  const opaque = block.opaque;
+  if (typeof opaque?.id !== "string" || typeof opaque.encrypted_content !== "string") {
+    throw new OpenAITranslationError("an OpenAI reasoning block carries no id or encrypted content");
+  }
+  return {
+    type: "reasoning",
+    id: opaque.id,
+    summary: Array.isArray(opaque.summary) ? opaque.summary : [],
+    encrypted_content: opaque.encrypted_content
+  };
+}
 function toFunctionCallOutput(block) {
   if (block.type !== "tool_result") {
     throw new OpenAITranslationError(
@@ -309,6 +630,8 @@ function toTool2(spec) {
 async function* translateOpenAIStream(events) {
   let sawToolCall = false;
   let sawRefusal = false;
+  let searches = 0;
+  const withSearches = (usage) => searches > 0 ? { ...usage, webSearchRequests: searches } : usage;
   for await (const event of events) {
     switch (event.type) {
       case "response.output_text.delta":
@@ -321,37 +644,66 @@ async function* translateOpenAIStream(events) {
       case "response.output_item.done":
         if (event.item.type === "function_call") {
           sawToolCall = true;
+          yield { type: "tool_call", id: event.item.call_id, name: event.item.name, ...parseToolArguments(event.item.arguments) };
+        } else if (event.item.type === "web_search_call") {
+          searches += 1;
+          const item = event.item;
+          const action = item.action;
+          const sources = action.type === "search" ? (action.sources ?? []).map((s) => ({ url: s.url })) : [];
+          yield { type: "provider_tool_call", block: { type: "provider_tool_call", id: item.id, name: "web_search", provider: "openai", input: action } };
+          yield {
+            type: "provider_tool_result",
+            block: {
+              type: "provider_tool_result",
+              callId: item.id,
+              name: "web_search",
+              provider: "openai",
+              results: sources,
+              ...item.status === "failed" ? { error: "failed" } : {},
+              opaque: item
+            }
+          };
+        } else if (event.item.type === "reasoning" && typeof event.item.encrypted_content === "string") {
+          const item = event.item;
+          const text = [
+            ...(item.content ?? []).map((c) => c.text),
+            ...item.summary.map((s) => s.text)
+          ].filter((t) => t !== "").join("\n");
           yield {
-            type: "tool_call",
-            id: event.item.call_id,
-            name: event.item.name,
-            input: event.item.arguments === "" ? {} : JSON.parse(event.item.arguments)
+            type: "reasoning",
+            block: {
+              type: "reasoning",
+              provider: "openai",
+              ...text !== "" ? { text } : {},
+              opaque: { id: item.id, summary: item.summary, encrypted_content: item.encrypted_content }
+            }
           };
         }
         break;
       case "response.completed":
-        yield usageEvent(event.response);
+        yield { type: "usage", usage: withSearches(usageOf(event.response)) };
         yield { type: "stop", reason: sawRefusal ? "refusal" : sawToolCall ? "tool_use" : "end_turn" };
         break;
       case "response.incomplete": {
-        yield usageEvent(event.response);
+        yield { type: "usage", usage: withSearches(usageOf(event.response)) };
         yield { type: "stop", reason: mapIncompleteReason(event.response) };
         break;
       }
       case "response.failed": {
         const err = event.response.error;
-        throw new OpenAITranslationError(
-          `OpenAI response failed: ${err ? `${err.code}: ${err.message}` : "unknown error"}`
-        );
+        const message = `OpenAI response failed: ${err ? `${err.code}: ${err.message}` : "unknown error"}`;
+        throw new OpenAITranslationError(message, classifyFailure("ResponseFailed", void 0, message.toLowerCase()));
+      }
+      case "error": {
+        const message = `OpenAI stream error: ${event.message}`;
+        throw new OpenAITranslationError(message, classifyFailure("StreamError", void 0, `${event.code ?? ""} ${message}`.toLowerCase()));
       }
-      case "error":
-        throw new OpenAITranslationError(`OpenAI stream error: ${event.message}`);
       default:
         break;
     }
   }
 }
-function usageEvent(response) {
+function usageOf(response) {
   const u = response.usage;
   const cachedRead = u?.input_tokens_details?.cached_tokens ?? 0;
   const usage = {
@@ -365,7 +717,12 @@ function usageEvent(response) {
   if (cachedRead > 0) usage.cacheReadInputTokens = cachedRead;
   const cacheWrite = u?.input_tokens_details?.cache_write_tokens;
   if (cacheWrite !== void 0 && cacheWrite > 0) usage.cacheWriteInputTokens = cacheWrite;
-  return { type: "usage", usage };
+  const reasoningTokens = u?.output_tokens_details?.reasoning_tokens;
+  if (reasoningTokens !== void 0 && reasoningTokens > 0) usage.reasoningTokens = reasoningTokens;
+  const served = response.service_tier;
+  if (served === "default") usage.serviceTier = "standard";
+  else if (served === "flex" || served === "priority") usage.serviceTier = served;
+  return usage;
 }
 function mapIncompleteReason(response) {
   const reason = response.incomplete_details?.reason;
@@ -376,7 +733,8 @@ function mapIncompleteReason(response) {
       return "refusal";
     default:
       throw new OpenAITranslationError(
-        `Unmapped OpenAI incomplete reason ${JSON.stringify(reason)} \u2014 provider drift?`
+        `Unmapped OpenAI incomplete reason ${JSON.stringify(reason)} \u2014 provider drift?`,
+        "provider_drift"
       );
   }
 }
@@ -395,21 +753,131 @@ var OpenAIModelClient = class {
     return translateOpenAIStream(this.#rawEvents(params, opts?.signal));
   }
   async *#rawEvents(params, signal) {
-    const stream = await this.#client.responses.create(
-      params,
-      signal !== void 0 ? { signal } : void 0
-    );
-    for await (const event of stream) yield event;
+    try {
+      const stream = await this.#client.responses.create(
+        params,
+        signal !== void 0 ? { signal } : void 0
+      );
+      for await (const event of stream) yield event;
+    } catch (err) {
+      throw toProviderError("openai", err);
+    }
+  }
+};
+
+// src/openai/jobs.ts
+import OpenAI2, { toFile } from "openai";
+function toBatchLines(items) {
+  return items.map((item) => {
+    const { serviceTier: _tier, ...req } = item.request;
+    void _tier;
+    const { stream: _stream, ...body } = toOpenAIParams(req);
+    void _stream;
+    return { custom_id: item.id, method: "POST", url: "/v1/responses", body };
+  });
+}
+function translateResponse(response) {
+  const blocks = [];
+  let sawToolCall = false;
+  let sawRefusal = false;
+  for (const item of response.output) {
+    switch (item.type) {
+      case "message":
+        for (const part of item.content) {
+          if (part.type === "output_text") blocks.push({ type: "text", text: part.text });
+          else if (part.type === "refusal") {
+            sawRefusal = true;
+            blocks.push({ type: "text", text: part.refusal });
+          }
+        }
+        break;
+      case "function_call":
+        sawToolCall = true;
+        blocks.push({ type: "tool_call", id: item.call_id, name: item.name, input: parseToolArguments(item.arguments).input });
+        break;
+      case "reasoning": {
+        if (typeof item.encrypted_content !== "string") break;
+        const text = [...(item.content ?? []).map((c) => c.text), ...item.summary.map((s) => s.text)].filter((t) => t !== "").join("\n");
+        blocks.push({
+          type: "reasoning",
+          provider: "openai",
+          ...text !== "" ? { text } : {},
+          opaque: { id: item.id, summary: item.summary, encrypted_content: item.encrypted_content }
+        });
+        break;
+      }
+      default:
+        throw new OpenAITranslationError(`Unmapped OpenAI output item ${JSON.stringify(item.type)} \u2014 provider drift?`, "provider_drift");
+    }
+  }
+  const stop = response.incomplete_details?.reason !== void 0 && response.incomplete_details?.reason !== null ? mapIncompleteReason(response) : sawRefusal ? "refusal" : sawToolCall ? "tool_use" : "end_turn";
+  return { blocks, usage: usageOf(response), stop };
+}
+var OpenAIJobClient = class {
+  #client;
+  constructor(opts = {}) {
+    const init = {};
+    if (opts.apiKey !== void 0) init.apiKey = opts.apiKey;
+    if (opts.baseURL !== void 0) init.baseURL = opts.baseURL;
+    this.#client = new OpenAI2(init);
+  }
+  async submit(items) {
+    const first = items[0];
+    if (!first) throw new OpenAITranslationError("a batch needs at least one item");
+    const jsonl = toBatchLines(items).map((line) => JSON.stringify(line)).join("\n") + "\n";
+    const file = await this.#client.files.create({
+      file: await toFile(Buffer.from(jsonl, "utf8"), "alma-batch.jsonl", { type: "application/jsonl" }),
+      purpose: "batch"
+    });
+    const batch = await this.#client.batches.create({
+      input_file_id: file.id,
+      endpoint: "/v1/responses",
+      completion_window: "24h"
+    });
+    return { provider: "openai", id: batch.id, model: first.request.model };
+  }
+  async status(handle) {
+    const batch = await this.#client.batches.retrieve(handle.id);
+    const status = batch.status === "validating" ? "queued" : batch.status === "in_progress" || batch.status === "finalizing" ? "running" : batch.status === "completed" ? "done" : batch.status === "failed" ? "failed" : batch.status === "expired" ? "expired" : "cancelled";
+    const c = batch.request_counts;
+    return {
+      status,
+      ...c ? { counts: { total: c.total, done: c.completed, failed: c.failed } } : {}
+    };
+  }
+  async *results(handle) {
+    const batch = await this.#client.batches.retrieve(handle.id);
+    for (const fileId of [batch.output_file_id, batch.error_file_id]) {
+      if (!fileId) continue;
+      const text = await (await this.#client.files.content(fileId)).text();
+      for (const raw of text.split("\n")) {
+        if (raw.trim() === "") continue;
+        const line = JSON.parse(raw);
+        const body = line.response?.body;
+        if (line.response && line.response.status_code >= 200 && line.response.status_code < 300 && body && "output" in body) {
+          yield { id: line.custom_id, outcome: "succeeded", output: translateResponse(body) };
+        } else {
+          const error = line.error?.message ?? (body && "error" in body ? body.error?.message : void 0) ?? `status ${line.response?.status_code ?? "unknown"}`;
+          yield { id: line.custom_id, outcome: "errored", error };
+        }
+      }
+    }
+  }
+  async cancel(handle) {
+    await this.#client.batches.cancel(handle.id);
   }
 };
 
 // src/openrouter/client.ts
-import OpenAI2 from "openai";
+import OpenAI3 from "openai";
 
 // src/openrouter/translate.ts
-var OpenRouterTranslationError = class extends Error {
-  constructor(message) {
-    super(message);
+import {
+  ProviderError as ProviderError4
+} from "@alma-harness/core";
+var OpenRouterTranslationError = class extends ProviderError4 {
+  constructor(message, kind = "rejected") {
+    super("openrouter", kind, message);
     this.name = "OpenRouterTranslationError";
   }
 };
@@ -428,6 +896,8 @@ function toOpenRouterParams(req, routing) {
   if (req.tools.length > 0) {
     provider.require_parameters = true;
   }
+  const reasoning = req.reasoning;
+  const replay = reasoning !== void 0 && reasoning.effort !== "none";
   const params = {
     model: req.model.id,
     // The SDK deprecates this in favor of the OpenAI-specific
@@ -438,9 +908,20 @@ function toOpenRouterParams(req, routing) {
     // Review amendment (spec 014): streamed chat completions only carry usage
     // when asked — without this the BudgetGuard never sees a usage event.
     stream_options: { include_usage: true },
-    messages: [...systemMessages(req.system), ...req.messages.flatMap(toWireMessages)],
+    messages: [...systemMessages(req.system), ...req.messages.flatMap((m) => toWireMessages(m, replay))],
     provider
   };
+  if (reasoning !== void 0) {
+    params.reasoning = replay ? { effort: reasoning.effort === "max" ? "xhigh" : reasoning.effort } : { enabled: false };
+  }
+  if (req.serviceTier !== void 0 && req.serviceTier !== "standard") {
+    throw new OpenRouterTranslationError(
+      `the OpenRouter adapter cannot serve the ${req.serviceTier} tier \u2014 the gateway prices by upstream`
+    );
+  }
+  if ((req.providerTools ?? []).length > 0) {
+    throw new OpenRouterTranslationError("the OpenRouter adapter cannot declare provider-executed tools \u2014 the gateway has no neutral web search");
+  }
   if (req.tools.length > 0) params.tools = req.tools.map(toTool3);
   return params;
 }
@@ -448,12 +929,12 @@ function systemMessages(blocks) {
   if (blocks.length === 0) return [];
   return [{ role: "system", content: blocks.map((b) => b.text).join("\n\n") }];
 }
-function toWireMessages(msg) {
+function toWireMessages(msg, replayReasoning) {
   switch (msg.role) {
     case "user":
       return [{ role: "user", content: msg.blocks.map(toUserContentPart2) }];
     case "assistant":
-      return [toAssistantMessage(msg.blocks)];
+      return [toAssistantMessage(msg.blocks, replayReasoning)];
     case "tool":
       return msg.blocks.map(toToolMessage);
   }
@@ -475,9 +956,10 @@ function toUserContentPart2(block) {
       );
   }
 }
-function toAssistantMessage(blocks) {
+function toAssistantMessage(blocks, replayReasoning) {
   let text = "";
   const toolCalls = [];
+  const details = [];
   for (const block of blocks) {
     switch (block.type) {
       case "text":
@@ -490,6 +972,16 @@ function toAssistantMessage(blocks) {
           function: { name: block.name, arguments: JSON.stringify(block.input) }
         });
         break;
+      case "reasoning": {
+        const opaque = block.opaque;
+        if (block.provider === "openrouter" && replayReasoning && Array.isArray(opaque?.reasoning_details)) {
+          details.push(...opaque.reasoning_details);
+        }
+        break;
+      }
+      case "provider_tool_call":
+      case "provider_tool_result":
+        break;
       default:
         throw new OpenRouterTranslationError(
           `block type ${JSON.stringify(block.type)} is not valid in an assistant message`
@@ -501,6 +993,7 @@ function toAssistantMessage(blocks) {
     content: text === "" ? null : text
   };
   if (toolCalls.length > 0) message.tool_calls = toolCalls;
+  if (details.length > 0) message.reasoning_details = details;
   return message;
 }
 function toToolMessage(block) {
@@ -533,9 +1026,15 @@ async function* translateOpenRouterStream(chunks) {
   let finish = null;
   let usage = null;
   let toolsEmitted = false;
+  let reasoningText = "";
+  const reasoningDetails = [];
+  let reasoningEmitted = false;
   for await (const chunk of chunks) {
     const choice = chunk.choices[0];
     if (choice) {
+      const extra = choice.delta;
+      if (typeof extra.reasoning === "string") reasoningText += extra.reasoning;
+      if (Array.isArray(extra.reasoning_details)) reasoningDetails.push(...extra.reasoning_details);
       if (choice.delta.content != null && choice.delta.content !== "") {
         yield { type: "text_delta", text: choice.delta.content };
       }
@@ -548,15 +1047,22 @@ async function* translateOpenRouterStream(chunks) {
       }
       if (choice.finish_reason != null) {
         finish = choice.finish_reason;
+        if (!reasoningEmitted && (reasoningText !== "" || reasoningDetails.length > 0)) {
+          reasoningEmitted = true;
+          yield {
+            type: "reasoning",
+            block: {
+              type: "reasoning",
+              provider: "openrouter",
+              ...reasoningText !== "" ? { text: reasoningText } : {},
+              ...reasoningDetails.length > 0 ? { opaque: { reasoning_details: reasoningDetails } } : {}
+            }
+          };
+        }
         if (!toolsEmitted) {
           toolsEmitted = true;
           for (const [, call] of [...pendingTools.entries()].sort(([a], [b]) => a - b)) {
-            yield {
-              type: "tool_call",
-              id: call.id,
-              name: call.name,
-              input: call.json === "" ? {} : JSON.parse(call.json)
-            };
+            yield { type: "tool_call", id: call.id, name: call.name, ...parseToolArguments(call.json) };
           }
           pendingTools.clear();
         }
@@ -571,11 +1077,14 @@ async function* translateOpenRouterStream(chunks) {
         outputTokens: chunk.usage.completion_tokens
       };
       if (cachedRead > 0) usage.cacheReadInputTokens = cachedRead;
+      const reasoningTokens = chunk.usage.completion_tokens_details?.reasoning_tokens;
+      if (reasoningTokens !== void 0 && reasoningTokens > 0) usage.reasoningTokens = reasoningTokens;
     }
   }
   if (finish === null) {
     throw new OpenRouterTranslationError(
-      "OpenRouter stream ended without a finish_reason \u2014 provider drift?"
+      "OpenRouter stream ended without a finish_reason \u2014 provider drift?",
+      "provider_drift"
     );
   }
   if (usage !== null) yield { type: "usage", usage };
@@ -593,7 +1102,8 @@ function mapFinishReason(reason) {
       return "refusal";
     default:
       throw new OpenRouterTranslationError(
-        `Unmapped OpenRouter finish_reason ${JSON.stringify(reason)} \u2014 provider drift?`
+        `Unmapped OpenRouter finish_reason ${JSON.stringify(reason)} \u2014 provider drift?`,
+        "provider_drift"
       );
   }
 }
@@ -620,36 +1130,47 @@ var OpenRouterModelClient = class {
         "OpenRouterModelClient needs an API key: pass `apiKey` or set OPENROUTER_API_KEY"
       );
     }
-    this.#client = new OpenAI2({ apiKey, baseURL: opts.baseURL ?? OPENROUTER_BASE_URL });
+    this.#client = new OpenAI3({ apiKey, baseURL: opts.baseURL ?? OPENROUTER_BASE_URL });
   }
   stream(req, opts) {
     const params = toOpenRouterParams(req, this.#routing);
     return translateOpenRouterStream(this.#rawChunks(params, opts?.signal));
   }
   async *#rawChunks(params, signal) {
-    const stream = await this.#client.chat.completions.create(
-      params,
-      signal !== void 0 ? { signal } : void 0
-    );
-    for await (const chunk of stream) yield chunk;
+    try {
+      const stream = await this.#client.chat.completions.create(
+        params,
+        signal !== void 0 ? { signal } : void 0
+      );
+      for await (const chunk of stream) yield chunk;
+    } catch (err) {
+      throw toProviderError("openrouter", err);
+    }
   }
 };
 
 // src/index.ts
 var SUPPORTED_PROVIDERS = ["anthropic", "openai", "openrouter"];
 export {
+  AnthropicJobClient,
   AnthropicModelClient,
   AnthropicTranslationError,
+  OpenAIJobClient,
   OpenAIModelClient,
   OpenAITranslationError,
   OpenRouterModelClient,
   OpenRouterTranslationError,
   SUPPORTED_PROVIDERS,
+  classifyFailure,
   toAnthropicParams,
+  toBatchLines,
   toOpenAIParams,
   toOpenRouterParams,
+  toProviderError,
+  translateMessage,
   translateOpenAIStream,
   translateOpenRouterStream,
+  translateResponse,
   translateStream
 };
 //# sourceMappingURL=index.js.map