@alma-harness/providers 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,61 @@
+# @alma-harness/providers
+
+`ModelClient` adapters for [Alma](https://github.com/FabioFernandesCarneiro/alma):
+Anthropic and OpenAI first-party, plus the OpenRouter gateway bridge, over one
+neutral message format.
+
+> **Status: pre-release.** Not yet published to npm.
+
+## What it owns
+
+- `AnthropicModelClient` — Messages API, streaming, with explicit
+  `cache_control` breakpoints at the stable-system boundary and the
+  conversation tail.
+- `OpenAIModelClient` — Responses API, streaming, automatic prefix caching.
+- `OpenRouterModelClient` — the gateway bridge (chat completions). A gateway
+  does not answer "who processed this data?" by itself, so construction
+  REQUIRES a declared upstream allowlist, fallbacks are off by default, data
+  collection is denied by default, and `require_parameters` rides along
+  whenever the request carries tools. Opening the catalogue changes nothing
+  about what the routing policy permits — that stays a product/DPO decision.
+- The translation between Alma's neutral `Msg`/`Block` format and each
+  provider's wire format, in both directions.
+
+Routing decides *which* client runs; the adapter only speaks the protocol.
+
+```ts
+import { OpenRouterModelClient } from "@alma-harness/providers";
+
+const client = new OpenRouterModelClient({
+  upstreams: ["deepinfra", "together"], // the declared data-processing chain
+});
+```
+
+## Credentials
+
+The harness never owns credentials. Each client accepts an explicitly injected
+key or falls back to the SDK's own environment resolution — configuration comes
+from the hosting environment, never from a file this repo reads.
+
+```ts
+import { AnthropicModelClient } from "@alma-harness/providers";
+
+const client = new AnthropicModelClient();          // reads ANTHROPIC_API_KEY
+const explicit = new AnthropicModelClient({ apiKey }); // or inject it
+```
+
+## What it must never do
+
+- Decide routing, spend, or capability. Those are core, not adapter.
+- Leak a provider type into the neutral format — the format is the boundary
+  that makes a second provider cheap.
+- Swallow provider drift: a stream that ends without a stop event fails loudly
+  rather than looking like a successful empty turn.
+
+## Documentation
+
+[Docs index](../../docs/README.md) · [Architecture §6.2](../../docs/architecture.md#6-contracts)
+· [Anthropic adapter spec](../../docs/specs/002-anthropic-provider.md)
+· [OpenAI adapter spec](../../docs/specs/003-openai-provider.md)
+
+Apache-2.0

package/dist/index.d.ts

@@ -0,0 +1,172 @@
+import { ModelClient, ModelRequest, ModelEvent } from '@alma-harness/core';
+export { ModelClient, ModelEvent, ModelRef, ModelRequest, ProviderId } from '@alma-harness/core';
+import Anthropic from '@anthropic-ai/sdk';
+import OpenAI from 'openai';
+
+interface AnthropicModelClientOptions {
+    /** Omit to use the SDK's environment resolution (ANTHROPIC_API_KEY, …). */
+    apiKey?: string;
+    baseURL?: string;
+}
+/**
+ * `ModelClient` adapter for the Anthropic Messages API — §6.2, spec 002.
+ * A thin shell: request/stream translation lives in ./translate (pure);
+ * this class only owns the SDK client. SDK typed errors propagate as-is.
+ */
+declare class AnthropicModelClient implements ModelClient {
+    #private;
+    constructor(opts?: AnthropicModelClientOptions);
+    stream(req: ModelRequest, opts?: {
+        signal?: AbortSignal;
+    }): AsyncIterable<ModelEvent>;
+}
+
+/**
+ * Pure translation between Alma's neutral vocabulary (§6.2) and the Anthropic
+ * Messages API — spec 002. Everything here is side-effect-free so the wire
+ * mapping is testable without a network.
+ */
+/** Raised when a request or stream cannot be represented faithfully. */
+declare class AnthropicTranslationError extends Error {
+    constructor(message: string);
+}
+declare function toAnthropicParams(req: ModelRequest): Anthropic.MessageCreateParamsStreaming;
+/**
+ * Raw SDK stream → neutral `ModelEvent`s. Tool inputs arrive as
+ * `input_json_delta` fragments; they are accumulated per content block and
+ * emitted as ONE `tool_call` with parsed input at `content_block_stop`.
+ * Usage is aggregated (input + cache fields from `message_start`, output from
+ * `message_delta`) and emitted once before the final `stop`.
+ */
+declare function translateStream(events: AsyncIterable<Anthropic.RawMessageStreamEvent>): AsyncGenerator<ModelEvent>;
+
+interface OpenAIModelClientOptions {
+    /** Omit to use the SDK's environment resolution (OPENAI_API_KEY). */
+    apiKey?: string;
+    baseURL?: string;
+}
+/**
+ * `ModelClient` adapter for the OpenAI Responses API — §6.2, spec 003.
+ * A thin shell: request/stream translation lives in ./translate (pure);
+ * this class only owns the SDK client. SDK typed errors propagate as-is.
+ */
+declare class OpenAIModelClient implements ModelClient {
+    #private;
+    constructor(opts?: OpenAIModelClientOptions);
+    stream(req: ModelRequest, opts?: {
+        signal?: AbortSignal;
+    }): AsyncIterable<ModelEvent>;
+}
+
+/**
+ * Pure translation between Alma's neutral vocabulary (§6.2) and the OpenAI
+ * Responses API — spec 003. Side-effect-free; testable without a network.
+ */
+declare class OpenAITranslationError extends Error {
+    constructor(message: string);
+}
+declare function toOpenAIParams(req: ModelRequest): OpenAI.Responses.ResponseCreateParamsStreaming;
+/**
+ * Semantic stream events → neutral `ModelEvent`s. Function-call arguments
+ * arrive complete on `response.output_item.done`, so each call is emitted as
+ * ONE parsed `tool_call`. The terminal `response.completed` / `.incomplete`
+ * event carries usage; `tool_use` is inferred from having emitted tool calls
+ * (the Responses API has no finish_reason).
+ */
+declare function translateOpenAIStream(events: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>): AsyncGenerator<ModelEvent>;
+
+/**
+ * Pure translation between Alma's neutral vocabulary (§6.2) and OpenRouter's
+ * chat-completions wire — spec 014. A SECOND translator over the neutral
+ * format, not a `baseURL` override: the first-party OpenAI adapter speaks the
+ * Responses API, and nothing in its translation is reusable here.
+ * Side-effect-free; testable without a network.
+ */
+declare class OpenRouterTranslationError extends Error {
+    constructor(message: string);
+}
+/**
+ * The upstream routing policy — spec 014's core constraint: for a gateway,
+ * "who processed this data?" must be a DECLARED fact, not an observed one.
+ */
+interface OpenRouterRouting {
+    /**
+     * OpenRouter provider slugs allowed to serve requests (→ `provider.only`).
+     * REQUIRED and non-empty: without it the data-processing chain has no
+     * answer, so the client refuses to construct.
+     */
+    upstreams: readonly string[];
+    /**
+     * Default false: a fallback is a silent change of data processor. Enabling
+     * it is a stated product choice, never a default.
+     */
+    allowFallbacks?: boolean;
+    /**
+     * Default "deny" — OpenRouter defaults to "allow", and a harness whose
+     * README says "operating on sensitive data" must not inherit the permissive
+     * default (spec 014 DECISION).
+     */
+    dataCollection?: "allow" | "deny";
+    /** Opt-in pass-through to OpenRouter's zero-data-retention guarantee. */
+    zeroDataRetention?: boolean;
+}
+/** The `provider` routing block OpenRouter accepts on every request. */
+interface OpenRouterProviderBlock {
+    only: string[];
+    allow_fallbacks: boolean;
+    data_collection: "allow" | "deny";
+    zdr?: boolean;
+    require_parameters?: boolean;
+}
+type OpenRouterParams = OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming & {
+    provider: OpenRouterProviderBlock;
+};
+declare function toOpenRouterParams(req: ModelRequest, routing: OpenRouterRouting): OpenRouterParams;
+/**
+ * Chat-completion chunks → neutral `ModelEvent`s. Tool-call arguments arrive
+ * as indexed fragments (id and name on the first fragment, argument pieces on
+ * the rest); they are accumulated per index and emitted as ONE parsed
+ * `tool_call` each when the choice finishes. The usage chunk arrives AFTER
+ * `finish_reason` (with `stream_options.include_usage`), so the terminal
+ * usage + stop pair is emitted at stream end — same order every adapter emits.
+ */
+declare function translateOpenRouterStream(chunks: AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>): AsyncGenerator<ModelEvent>;
+
+interface OpenRouterModelClientOptions extends OpenRouterRouting {
+    /** Omit to read OPENROUTER_API_KEY (the OpenAI SDK's own env resolution
+     * would read OPENAI_API_KEY — the wrong credential for this gateway). */
+    apiKey?: string;
+    /** Defaults to OpenRouter's public endpoint. */
+    baseURL?: string;
+}
+/**
+ * `ModelClient` adapter for OpenRouter — §6.2, spec 014 (the gateway bridge).
+ * Same thin-shell shape as the first-party adapters: translation lives in
+ * ./translate (pure); this class owns the SDK client and the DECLARED
+ * upstream policy. A gateway erases "who processed this data?" unless the
+ * chain is declared beforehand, so construction REFUSES to proceed without a
+ * non-empty upstream allowlist — deciding after the fact enforces nothing.
+ */
+declare class OpenRouterModelClient implements ModelClient {
+    #private;
+    constructor(opts: OpenRouterModelClientOptions);
+    stream(req: ModelRequest, opts?: {
+        signal?: AbortSignal;
+    }): AsyncIterable<ModelEvent>;
+}
+
+/**
+ * @alma-harness/providers — `ModelClient` adapters (§6.2).
+ * Bi-provider from birth — `AnthropicModelClient` (spec 002) and
+ * `OpenAIModelClient` (spec 003) — plus the OpenRouter gateway bridge
+ * (spec 014), all over the same neutral surface.
+ */
+
+/**
+ * First-party from birth (§3 principle 4), plus the gateway bridge —
+ * spec 014: `openrouter` names the EXIT, not the processor; its adapter
+ * requires a declared upstream allowlist for exactly that reason.
+ */
+declare const SUPPORTED_PROVIDERS: readonly ["anthropic", "openai", "openrouter"];
+
+export { AnthropicModelClient, type AnthropicModelClientOptions, AnthropicTranslationError, OpenAIModelClient, type OpenAIModelClientOptions, OpenAITranslationError, OpenRouterModelClient, type OpenRouterModelClientOptions, type OpenRouterParams, type OpenRouterRouting, OpenRouterTranslationError, SUPPORTED_PROVIDERS, toAnthropicParams, toOpenAIParams, toOpenRouterParams, translateOpenAIStream, translateOpenRouterStream, translateStream };

package/dist/index.js

@@ -0,0 +1,655 @@
+// src/anthropic/client.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/anthropic/translate.ts
+var AnthropicTranslationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AnthropicTranslationError";
+  }
+};
+function toAnthropicParams(req) {
+  if (req.model.provider !== "anthropic") {
+    throw new AnthropicTranslationError(
+      `AnthropicModelClient received a request for provider ${JSON.stringify(req.model.provider)}`
+    );
+  }
+  const params = {
+    model: req.model.id,
+    max_tokens: req.maxTokens,
+    stream: true,
+    system: toSystem(req.system),
+    messages: req.messages.map(toMessageParam)
+  };
+  if (req.tools.length > 0) params.tools = req.tools.map(toTool);
+  markConversationTail(params.messages);
+  return params;
+}
+function markConversationTail(messages) {
+  const last = messages.at(-1);
+  if (!last || typeof last.content === "string") return;
+  const block = last.content.at(-1);
+  if (block) block.cache_control = { type: "ephemeral" };
+}
+function toSystem(blocks) {
+  const lastStable = blocks.reduce(
+    (last, b, i) => b.volatility === "stable" ? i : last,
+    -1
+  );
+  return blocks.map((b, i) => {
+    const param = { type: "text", text: b.text };
+    if (i === lastStable) param.cache_control = { type: "ephemeral" };
+    return param;
+  });
+}
+function toMessageParam(msg) {
+  switch (msg.role) {
+    case "user":
+      return { role: "user", content: msg.blocks.map(toUserBlock) };
+    case "assistant":
+      return { role: "assistant", content: msg.blocks.map(toAssistantBlock) };
+    case "tool":
+      return { role: "user", content: msg.blocks.map(toToolResultBlock) };
+  }
+}
+function toUserBlock(block) {
+  switch (block.type) {
+    case "text":
+      return { type: "text", text: block.text };
+    case "media":
+      switch (block.kind) {
+        case "image":
+          return { type: "image", source: { type: "url", url: block.ref.uri } };
+        case "document":
+          return { type: "document", source: { type: "url", url: block.ref.uri } };
+        case "audio":
+          throw new AnthropicTranslationError("audio media is not supported by the Anthropic adapter");
+      }
+    default:
+      throw new AnthropicTranslationError(`block type ${JSON.stringify(block.type)} is not valid in a user message`);
+  }
+}
+function toAssistantBlock(block) {
+  switch (block.type) {
+    case "text":
+      return { type: "text", text: block.text };
+    case "tool_call":
+      return { type: "tool_use", id: block.id, name: block.name, input: block.input };
+    default:
+      throw new AnthropicTranslationError(
+        `block type ${JSON.stringify(block.type)} is not valid in an assistant message`
+      );
+  }
+}
+function toToolResultBlock(block) {
+  if (block.type !== "tool_result") {
+    throw new AnthropicTranslationError(
+      `block type ${JSON.stringify(block.type)} is not valid in a tool message`
+    );
+  }
+  const param = {
+    type: "tool_result",
+    tool_use_id: block.callId,
+    // JSON.stringify yields undefined (not a string) for undefined/functions;
+    // "null" keeps the content explicit for void tool outputs.
+    content: typeof block.output === "string" ? block.output : JSON.stringify(block.output) ?? "null"
+  };
+  if (block.isError) param.is_error = true;
+  return param;
+}
+function toTool(spec) {
+  return {
+    name: spec.name,
+    description: spec.description,
+    // The registry already derived a JSON Schema object (§6.4).
+    input_schema: spec.inputSchema
+  };
+}
+async function* translateStream(events) {
+  const usage = { inputTokens: 0, outputTokens: 0 };
+  let stopReason = null;
+  const pendingTools = /* @__PURE__ */ new Map();
+  for await (const event of events) {
+    switch (event.type) {
+      case "message_start": {
+        const u = event.message.usage;
+        usage.inputTokens = u.input_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;
+        }
+        break;
+      }
+      case "content_block_start":
+        if (event.content_block.type === "tool_use") {
+          pendingTools.set(event.index, {
+            id: event.content_block.id,
+            name: event.content_block.name,
+            json: ""
+          });
+        }
+        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);
+          if (pending) pending.json += event.delta.partial_json;
+        }
+        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,
+            input: pending.json === "" ? {} : JSON.parse(pending.json)
+          };
+        }
+        break;
+      }
+      case "message_delta":
+        if (event.delta.stop_reason != null) stopReason = event.delta.stop_reason;
+        usage.outputTokens = event.usage.output_tokens;
+        break;
+      case "message_stop":
+        yield { type: "usage", usage: { ...usage } };
+        yield { type: "stop", reason: mapStopReason(stopReason) };
+        break;
+    }
+  }
+}
+function mapStopReason(reason) {
+  switch (reason) {
+    case "end_turn":
+    case "stop_sequence":
+      return "end_turn";
+    case "tool_use":
+      return "tool_use";
+    case "max_tokens":
+      return "max_tokens";
+    case "refusal":
+      return "refusal";
+    case "model_context_window_exceeded":
+      return "context_window_exceeded";
+    default:
+      throw new AnthropicTranslationError(
+        `Unmapped Anthropic stop_reason ${JSON.stringify(reason)} \u2014 provider drift?`
+      );
+  }
+}
+
+// src/anthropic/client.ts
+var AnthropicModelClient = 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 Anthropic(init);
+  }
+  stream(req, opts) {
+    const params = toAnthropicParams(req);
+    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;
+  }
+};
+
+// src/openai/client.ts
+import OpenAI from "openai";
+
+// src/openai/translate.ts
+var OpenAITranslationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OpenAITranslationError";
+  }
+};
+function toOpenAIParams(req) {
+  if (req.model.provider !== "openai") {
+    throw new OpenAITranslationError(
+      `OpenAIModelClient received a request for provider ${JSON.stringify(req.model.provider)}`
+    );
+  }
+  const params = {
+    model: req.model.id,
+    max_output_tokens: req.maxTokens,
+    stream: true,
+    // 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)
+  };
+  const instructions = toInstructions(req.system);
+  if (instructions !== "") params.instructions = instructions;
+  if (req.tools.length > 0) params.tools = req.tools.map(toTool2);
+  return params;
+}
+function toInstructions(blocks) {
+  return blocks.map((b) => b.text).join("\n\n");
+}
+function toInputItems(msg) {
+  switch (msg.role) {
+    case "user":
+      return [{ role: "user", content: msg.blocks.map(toUserContentPart) }];
+    case "assistant":
+      return msg.blocks.map(toAssistantItem);
+    case "tool":
+      return msg.blocks.map(toFunctionCallOutput);
+  }
+}
+function toUserContentPart(block) {
+  switch (block.type) {
+    case "text":
+      return { type: "input_text", text: block.text };
+    case "media":
+      if (block.kind === "image") {
+        return { type: "input_image", detail: "auto", image_url: block.ref.uri };
+      }
+      throw new OpenAITranslationError(
+        `${block.kind} media is not supported by the OpenAI adapter`
+      );
+    default:
+      throw new OpenAITranslationError(
+        `block type ${JSON.stringify(block.type)} is not valid in a user message`
+      );
+  }
+}
+function toAssistantItem(block) {
+  switch (block.type) {
+    case "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)
+      };
+    default:
+      throw new OpenAITranslationError(
+        `block type ${JSON.stringify(block.type)} is not valid in an assistant message`
+      );
+  }
+}
+function toFunctionCallOutput(block) {
+  if (block.type !== "tool_result") {
+    throw new OpenAITranslationError(
+      `block type ${JSON.stringify(block.type)} is not valid in a tool message`
+    );
+  }
+  const serialized = typeof block.output === "string" ? block.output : JSON.stringify(block.output) ?? "null";
+  return {
+    type: "function_call_output",
+    call_id: block.callId,
+    // The Responses API has no is_error flag on function outputs — an
+    // explicit prefix keeps failures visible to the model (spec 003).
+    output: block.isError ? `ERROR: ${serialized}` : serialized
+  };
+}
+function toTool2(spec) {
+  return {
+    type: "function",
+    name: spec.name,
+    description: spec.description,
+    parameters: spec.inputSchema,
+    // Registry-derived schemas are not guaranteed strict-compatible; the
+    // structured-output surface is a follow-up slice (spec 003 decision).
+    strict: false
+  };
+}
+async function* translateOpenAIStream(events) {
+  let sawToolCall = false;
+  let sawRefusal = false;
+  for await (const event of events) {
+    switch (event.type) {
+      case "response.output_text.delta":
+        yield { type: "text_delta", text: event.delta };
+        break;
+      case "response.refusal.delta":
+        sawRefusal = true;
+        yield { type: "text_delta", text: event.delta };
+        break;
+      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,
+            input: event.item.arguments === "" ? {} : JSON.parse(event.item.arguments)
+          };
+        }
+        break;
+      case "response.completed":
+        yield usageEvent(event.response);
+        yield { type: "stop", reason: sawRefusal ? "refusal" : sawToolCall ? "tool_use" : "end_turn" };
+        break;
+      case "response.incomplete": {
+        yield usageEvent(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"}`
+        );
+      }
+      case "error":
+        throw new OpenAITranslationError(`OpenAI stream error: ${event.message}`);
+      default:
+        break;
+    }
+  }
+}
+function usageEvent(response) {
+  const u = response.usage;
+  const cachedRead = u?.input_tokens_details?.cached_tokens ?? 0;
+  const usage = {
+    // Neutral semantics (spec 005): inputTokens EXCLUDES cache reads.
+    // OpenAI's input_tokens includes cached_tokens; subtract to normalize —
+    // otherwise the BudgetGuard would price the same conversation
+    // differently per provider.
+    inputTokens: Math.max(0, (u?.input_tokens ?? 0) - cachedRead),
+    outputTokens: u?.output_tokens ?? 0
+  };
+  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 };
+}
+function mapIncompleteReason(response) {
+  const reason = response.incomplete_details?.reason;
+  switch (reason) {
+    case "max_output_tokens":
+      return "max_tokens";
+    case "content_filter":
+      return "refusal";
+    default:
+      throw new OpenAITranslationError(
+        `Unmapped OpenAI incomplete reason ${JSON.stringify(reason)} \u2014 provider drift?`
+      );
+  }
+}
+
+// src/openai/client.ts
+var OpenAIModelClient = 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 OpenAI(init);
+  }
+  stream(req, opts) {
+    const params = toOpenAIParams(req);
+    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;
+  }
+};
+
+// src/openrouter/client.ts
+import OpenAI2 from "openai";
+
+// src/openrouter/translate.ts
+var OpenRouterTranslationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OpenRouterTranslationError";
+  }
+};
+function toOpenRouterParams(req, routing) {
+  if (req.model.provider !== "openrouter") {
+    throw new OpenRouterTranslationError(
+      `OpenRouterModelClient received a request for provider ${JSON.stringify(req.model.provider)}`
+    );
+  }
+  const provider = {
+    only: [...routing.upstreams],
+    allow_fallbacks: routing.allowFallbacks ?? false,
+    data_collection: routing.dataCollection ?? "deny"
+  };
+  if (routing.zeroDataRetention === true) provider.zdr = true;
+  if (req.tools.length > 0) {
+    provider.require_parameters = true;
+  }
+  const params = {
+    model: req.model.id,
+    // The SDK deprecates this in favor of the OpenAI-specific
+    // max_completion_tokens; for a gateway fronting heterogeneous upstreams,
+    // max_tokens is the common denominator OpenRouter documents.
+    max_tokens: req.maxTokens,
+    stream: true,
+    // 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)],
+    provider
+  };
+  if (req.tools.length > 0) params.tools = req.tools.map(toTool3);
+  return params;
+}
+function systemMessages(blocks) {
+  if (blocks.length === 0) return [];
+  return [{ role: "system", content: blocks.map((b) => b.text).join("\n\n") }];
+}
+function toWireMessages(msg) {
+  switch (msg.role) {
+    case "user":
+      return [{ role: "user", content: msg.blocks.map(toUserContentPart2) }];
+    case "assistant":
+      return [toAssistantMessage(msg.blocks)];
+    case "tool":
+      return msg.blocks.map(toToolMessage);
+  }
+}
+function toUserContentPart2(block) {
+  switch (block.type) {
+    case "text":
+      return { type: "text", text: block.text };
+    case "media":
+      if (block.kind === "image") {
+        return { type: "image_url", image_url: { url: block.ref.uri } };
+      }
+      throw new OpenRouterTranslationError(
+        `${block.kind} media is not supported by the OpenRouter adapter`
+      );
+    default:
+      throw new OpenRouterTranslationError(
+        `block type ${JSON.stringify(block.type)} is not valid in a user message`
+      );
+  }
+}
+function toAssistantMessage(blocks) {
+  let text = "";
+  const toolCalls = [];
+  for (const block of blocks) {
+    switch (block.type) {
+      case "text":
+        text += block.text;
+        break;
+      case "tool_call":
+        toolCalls.push({
+          id: block.id,
+          type: "function",
+          function: { name: block.name, arguments: JSON.stringify(block.input) }
+        });
+        break;
+      default:
+        throw new OpenRouterTranslationError(
+          `block type ${JSON.stringify(block.type)} is not valid in an assistant message`
+        );
+    }
+  }
+  const message = {
+    role: "assistant",
+    content: text === "" ? null : text
+  };
+  if (toolCalls.length > 0) message.tool_calls = toolCalls;
+  return message;
+}
+function toToolMessage(block) {
+  if (block.type !== "tool_result") {
+    throw new OpenRouterTranslationError(
+      `block type ${JSON.stringify(block.type)} is not valid in a tool message`
+    );
+  }
+  const serialized = typeof block.output === "string" ? block.output : JSON.stringify(block.output) ?? "null";
+  return {
+    role: "tool",
+    tool_call_id: block.callId,
+    // No is_error flag on this wire either — the explicit prefix keeps
+    // failures visible to the model (spec 003's precedent).
+    content: block.isError ? `ERROR: ${serialized}` : serialized
+  };
+}
+function toTool3(spec) {
+  return {
+    type: "function",
+    function: {
+      name: spec.name,
+      description: spec.description,
+      parameters: spec.inputSchema
+    }
+  };
+}
+async function* translateOpenRouterStream(chunks) {
+  const pendingTools = /* @__PURE__ */ new Map();
+  let finish = null;
+  let usage = null;
+  let toolsEmitted = false;
+  for await (const chunk of chunks) {
+    const choice = chunk.choices[0];
+    if (choice) {
+      if (choice.delta.content != null && choice.delta.content !== "") {
+        yield { type: "text_delta", text: choice.delta.content };
+      }
+      for (const fragment of choice.delta.tool_calls ?? []) {
+        const pending = pendingTools.get(fragment.index) ?? { id: "", name: "", json: "" };
+        if (fragment.id != null) pending.id = fragment.id;
+        if (fragment.function?.name != null) pending.name = fragment.function.name;
+        if (fragment.function?.arguments != null) pending.json += fragment.function.arguments;
+        pendingTools.set(fragment.index, pending);
+      }
+      if (choice.finish_reason != null) {
+        finish = choice.finish_reason;
+        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)
+            };
+          }
+          pendingTools.clear();
+        }
+      }
+    }
+    if (chunk.usage != null) {
+      const cachedRead = chunk.usage.prompt_tokens_details?.cached_tokens ?? 0;
+      usage = {
+        // Neutral semantics (spec 005): inputTokens EXCLUDES cache reads —
+        // the wire's prompt_tokens includes them.
+        inputTokens: Math.max(0, chunk.usage.prompt_tokens - cachedRead),
+        outputTokens: chunk.usage.completion_tokens
+      };
+      if (cachedRead > 0) usage.cacheReadInputTokens = cachedRead;
+    }
+  }
+  if (finish === null) {
+    throw new OpenRouterTranslationError(
+      "OpenRouter stream ended without a finish_reason \u2014 provider drift?"
+    );
+  }
+  if (usage !== null) yield { type: "usage", usage };
+  yield { type: "stop", reason: mapFinishReason(finish) };
+}
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+      return "end_turn";
+    case "tool_calls":
+      return "tool_use";
+    case "length":
+      return "max_tokens";
+    case "content_filter":
+      return "refusal";
+    default:
+      throw new OpenRouterTranslationError(
+        `Unmapped OpenRouter finish_reason ${JSON.stringify(reason)} \u2014 provider drift?`
+      );
+  }
+}
+
+// src/openrouter/client.ts
+var OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+var OpenRouterModelClient = class {
+  #client;
+  #routing;
+  constructor(opts) {
+    if (!Array.isArray(opts.upstreams) || opts.upstreams.length === 0) {
+      throw new Error(
+        "OpenRouterModelClient requires a non-empty `upstreams` allowlist \u2014 for a gateway, the data-processing chain must be a declared fact (spec 014)"
+      );
+    }
+    const routing = { upstreams: [...opts.upstreams] };
+    if (opts.allowFallbacks !== void 0) routing.allowFallbacks = opts.allowFallbacks;
+    if (opts.dataCollection !== void 0) routing.dataCollection = opts.dataCollection;
+    if (opts.zeroDataRetention !== void 0) routing.zeroDataRetention = opts.zeroDataRetention;
+    this.#routing = routing;
+    const apiKey = opts.apiKey ?? process.env["OPENROUTER_API_KEY"];
+    if (apiKey === void 0 || apiKey === "") {
+      throw new Error(
+        "OpenRouterModelClient needs an API key: pass `apiKey` or set OPENROUTER_API_KEY"
+      );
+    }
+    this.#client = new OpenAI2({ 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;
+  }
+};
+
+// src/index.ts
+var SUPPORTED_PROVIDERS = ["anthropic", "openai", "openrouter"];
+export {
+  AnthropicModelClient,
+  AnthropicTranslationError,
+  OpenAIModelClient,
+  OpenAITranslationError,
+  OpenRouterModelClient,
+  OpenRouterTranslationError,
+  SUPPORTED_PROVIDERS,
+  toAnthropicParams,
+  toOpenAIParams,
+  toOpenRouterParams,
+  translateOpenAIStream,
+  translateOpenRouterStream,
+  translateStream
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/anthropic/client.ts","../src/anthropic/translate.ts","../src/openai/client.ts","../src/openai/translate.ts","../src/openrouter/client.ts","../src/openrouter/translate.ts","../src/index.ts"],"sourcesContent":["import Anthropic from \"@anthropic-ai/sdk\";\nimport type { ModelClient, ModelEvent, ModelRequest } from \"@alma-harness/core\";\n\nimport { toAnthropicParams, translateStream } from \"./translate\";\n\nexport interface AnthropicModelClientOptions {\n  /** Omit to use the SDK's environment resolution (ANTHROPIC_API_KEY, …). */\n  apiKey?: string;\n  baseURL?: string;\n}\n\n/**\n * `ModelClient` adapter for the Anthropic Messages API — §6.2, spec 002.\n * A thin shell: request/stream translation lives in ./translate (pure);\n * this class only owns the SDK client. SDK typed errors propagate as-is.\n */\nexport class AnthropicModelClient implements ModelClient {\n  readonly #client: Anthropic;\n\n  constructor(opts: AnthropicModelClientOptions = {}) {\n    const init: ConstructorParameters<typeof Anthropic>[0] = {};\n    if (opts.apiKey !== undefined) init.apiKey = opts.apiKey;\n    if (opts.baseURL !== undefined) init.baseURL = opts.baseURL;\n    this.#client = new Anthropic(init);\n  }\n\n  stream(req: ModelRequest, opts?: { signal?: AbortSignal }): AsyncIterable<ModelEvent> {\n    // Translation throws synchronously (wrong provider, unsupported blocks)\n    // before any network activity — spec 002 criterion 5.\n    const params = toAnthropicParams(req);\n    return translateStream(this.#rawEvents(params, opts?.signal));\n  }\n\n  async *#rawEvents(\n    params: Anthropic.MessageCreateParamsStreaming,\n    signal?: AbortSignal,\n  ): AsyncGenerator<Anthropic.RawMessageStreamEvent> {\n    const stream = await this.#client.messages.create(\n      params,\n      signal !== undefined ? { signal } : undefined,\n    );\n    for await (const event of stream) yield event;\n  }\n}\n","import type Anthropic from \"@anthropic-ai/sdk\";\n\nimport type {\n  Block,\n  ModelEvent,\n  ModelRequest,\n  Msg,\n  StopReason,\n  SystemBlock,\n  ToolSpec,\n  Usage,\n} from \"@alma-harness/core\";\n\n/**\n * Pure translation between Alma's neutral vocabulary (§6.2) and the Anthropic\n * Messages API — spec 002. Everything here is side-effect-free so the wire\n * mapping is testable without a network.\n */\n\n/** Raised when a request or stream cannot be represented faithfully. */\nexport class AnthropicTranslationError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"AnthropicTranslationError\";\n  }\n}\n\nexport function toAnthropicParams(req: ModelRequest): Anthropic.MessageCreateParamsStreaming {\n  if (req.model.provider !== \"anthropic\") {\n    throw new AnthropicTranslationError(\n      `AnthropicModelClient received a request for provider ${JSON.stringify(req.model.provider)}`,\n    );\n  }\n  const params: Anthropic.MessageCreateParamsStreaming = {\n    model: req.model.id,\n    max_tokens: req.maxTokens,\n    stream: true,\n    system: toSystem(req.system),\n    messages: req.messages.map(toMessageParam),\n  };\n  if (req.tools.length > 0) params.tools = req.tools.map(toTool);\n  markConversationTail(params.messages);\n  return params;\n}\n\n/**\n * Cache continuation — spec 005: a second breakpoint on the conversation\n * tail lets multi-turn sessions pay incremental tokens instead of re-reading\n * the whole history every turn. (Budget: 2 of the 4 allowed breakpoints —\n * one at the stable-system boundary, one here.)\n */\nfunction markConversationTail(messages: Anthropic.MessageParam[]): void {\n  const last = messages.at(-1);\n  if (!last || typeof last.content === \"string\") return;\n  const block = last.content.at(-1);\n  if (block) (block as { cache_control?: Anthropic.CacheControlEphemeral }).cache_control = { type: \"ephemeral\" };\n}\n\n/**\n * The §6.9 stable/volatile boundary becomes the cache boundary: one\n * `cache_control` breakpoint on the LAST stable block, volatile blocks after\n * it. Order is preserved — callers must already emit stable-first.\n */\nfunction toSystem(blocks: SystemBlock[]): Anthropic.TextBlockParam[] {\n  const lastStable = blocks.reduce(\n    (last, b, i) => (b.volatility === \"stable\" ? i : last),\n    -1,\n  );\n  return blocks.map((b, i) => {\n    const param: Anthropic.TextBlockParam = { type: \"text\", text: b.text };\n    if (i === lastStable) param.cache_control = { type: \"ephemeral\" };\n    return param;\n  });\n}\n\nfunction toMessageParam(msg: Msg): Anthropic.MessageParam {\n  switch (msg.role) {\n    case \"user\":\n      return { role: \"user\", content: msg.blocks.map(toUserBlock) };\n    case \"assistant\":\n      return { role: \"assistant\", content: msg.blocks.map(toAssistantBlock) };\n    case \"tool\":\n      // Anthropic's wire shape: tool results travel in a user-role message.\n      return { role: \"user\", content: msg.blocks.map(toToolResultBlock) };\n  }\n}\n\nfunction toUserBlock(block: Block): Anthropic.ContentBlockParam {\n  switch (block.type) {\n    case \"text\":\n      return { type: \"text\", text: block.text };\n    case \"media\":\n      switch (block.kind) {\n        case \"image\":\n          return { type: \"image\", source: { type: \"url\", url: block.ref.uri } };\n        case \"document\":\n          return { type: \"document\", source: { type: \"url\", url: block.ref.uri } };\n        case \"audio\":\n          // The Messages API takes no raw audio; products transcribe upstream.\n          throw new AnthropicTranslationError(\"audio media is not supported by the Anthropic adapter\");\n      }\n    default:\n      throw new AnthropicTranslationError(`block type ${JSON.stringify(block.type)} is not valid in a user message`);\n  }\n}\n\nfunction toAssistantBlock(block: Block): Anthropic.ContentBlockParam {\n  switch (block.type) {\n    case \"text\":\n      return { type: \"text\", text: block.text };\n    case \"tool_call\":\n      return { type: \"tool_use\", id: block.id, name: block.name, input: block.input };\n    default:\n      throw new AnthropicTranslationError(\n        `block type ${JSON.stringify(block.type)} is not valid in an assistant message`,\n      );\n  }\n}\n\nfunction toToolResultBlock(block: Block): Anthropic.ToolResultBlockParam {\n  if (block.type !== \"tool_result\") {\n    throw new AnthropicTranslationError(\n      `block type ${JSON.stringify(block.type)} is not valid in a tool message`,\n    );\n  }\n  const param: Anthropic.ToolResultBlockParam = {\n    type: \"tool_result\",\n    tool_use_id: block.callId,\n    // JSON.stringify yields undefined (not a string) for undefined/functions;\n    // \"null\" keeps the content explicit for void tool outputs.\n    content:\n      typeof block.output === \"string\" ? block.output : (JSON.stringify(block.output) ?? \"null\"),\n  };\n  if (block.isError) param.is_error = true;\n  return param;\n}\n\nfunction toTool(spec: ToolSpec): Anthropic.Tool {\n  return {\n    name: spec.name,\n    description: spec.description,\n    // The registry already derived a JSON Schema object (§6.4).\n    input_schema: spec.inputSchema as Anthropic.Tool.InputSchema,\n  };\n}\n\n/**\n * Raw SDK stream → neutral `ModelEvent`s. Tool inputs arrive as\n * `input_json_delta` fragments; they are accumulated per content block and\n * emitted as ONE `tool_call` with parsed input at `content_block_stop`.\n * Usage is aggregated (input + cache fields from `message_start`, output from\n * `message_delta`) and emitted once before the final `stop`.\n */\nexport async function* translateStream(\n  events: AsyncIterable<Anthropic.RawMessageStreamEvent>,\n): AsyncGenerator<ModelEvent> {\n  const usage: Usage = { inputTokens: 0, outputTokens: 0 };\n  let stopReason: Anthropic.Message[\"stop_reason\"] = null;\n  const pendingTools = new Map<number, { id: string; name: string; json: string }>();\n\n  for await (const event of events) {\n    switch (event.type) {\n      case \"message_start\": {\n        const u = event.message.usage;\n        usage.inputTokens = u.input_tokens;\n        if (u.cache_read_input_tokens != null) usage.cacheReadInputTokens = u.cache_read_input_tokens;\n        if (u.cache_creation_input_tokens != null) {\n          usage.cacheWriteInputTokens = u.cache_creation_input_tokens;\n        }\n        break;\n      }\n      case \"content_block_start\":\n        if (event.content_block.type === \"tool_use\") {\n          pendingTools.set(event.index, {\n            id: event.content_block.id,\n            name: event.content_block.name,\n            json: \"\",\n          });\n        }\n        break;\n      case \"content_block_delta\":\n        if (event.delta.type === \"text_delta\") {\n          yield { type: \"text_delta\", text: event.delta.text };\n        } else if (event.delta.type === \"input_json_delta\") {\n          const pending = pendingTools.get(event.index);\n          if (pending) pending.json += event.delta.partial_json;\n        }\n        break;\n      case \"content_block_stop\": {\n        const pending = pendingTools.get(event.index);\n        if (pending) {\n          pendingTools.delete(event.index);\n          yield {\n            type: \"tool_call\",\n            id: pending.id,\n            name: pending.name,\n            input: pending.json === \"\" ? {} : (JSON.parse(pending.json) as unknown),\n          };\n        }\n        break;\n      }\n      case \"message_delta\":\n        if (event.delta.stop_reason != null) stopReason = event.delta.stop_reason;\n        usage.outputTokens = event.usage.output_tokens;\n        break;\n      case \"message_stop\":\n        yield { type: \"usage\", usage: { ...usage } };\n        yield { type: \"stop\", reason: mapStopReason(stopReason) };\n        break;\n    }\n  }\n}\n\nfunction mapStopReason(reason: Anthropic.Message[\"stop_reason\"]): StopReason {\n  switch (reason) {\n    case \"end_turn\":\n    case \"stop_sequence\":\n      return \"end_turn\";\n    case \"tool_use\":\n      return \"tool_use\";\n    case \"max_tokens\":\n      return \"max_tokens\";\n    case \"refusal\":\n      return \"refusal\";\n    case \"model_context_window_exceeded\":\n      return \"context_window_exceeded\";\n    default:\n      // pause_turn (server-side tools the harness never declares — spec 002\n      // known deferral) or a reason newer than this adapter: refuse loudly\n      // rather than silently truncate.\n      throw new AnthropicTranslationError(\n        `Unmapped Anthropic stop_reason ${JSON.stringify(reason)} — provider drift?`,\n      );\n  }\n}\n","import OpenAI from \"openai\";\nimport type { ModelClient, ModelEvent, ModelRequest } from \"@alma-harness/core\";\n\nimport { toOpenAIParams, translateOpenAIStream } from \"./translate\";\n\nexport interface OpenAIModelClientOptions {\n  /** Omit to use the SDK's environment resolution (OPENAI_API_KEY). */\n  apiKey?: string;\n  baseURL?: string;\n}\n\n/**\n * `ModelClient` adapter for the OpenAI Responses API — §6.2, spec 003.\n * A thin shell: request/stream translation lives in ./translate (pure);\n * this class only owns the SDK client. SDK typed errors propagate as-is.\n */\nexport class OpenAIModelClient implements ModelClient {\n  readonly #client: OpenAI;\n\n  constructor(opts: OpenAIModelClientOptions = {}) {\n    const init: ConstructorParameters<typeof OpenAI>[0] = {};\n    if (opts.apiKey !== undefined) init.apiKey = opts.apiKey;\n    if (opts.baseURL !== undefined) init.baseURL = opts.baseURL;\n    this.#client = new OpenAI(init);\n  }\n\n  stream(req: ModelRequest, opts?: { signal?: AbortSignal }): AsyncIterable<ModelEvent> {\n    // Translation throws synchronously (wrong provider, unsupported blocks)\n    // before any network activity — spec 003 criterion 6.\n    const params = toOpenAIParams(req);\n    return translateOpenAIStream(this.#rawEvents(params, opts?.signal));\n  }\n\n  async *#rawEvents(\n    params: OpenAI.Responses.ResponseCreateParamsStreaming,\n    signal?: AbortSignal,\n  ): AsyncGenerator<OpenAI.Responses.ResponseStreamEvent> {\n    const stream = await this.#client.responses.create(\n      params,\n      signal !== undefined ? { signal } : undefined,\n    );\n    for await (const event of stream) yield event;\n  }\n}\n","import type OpenAI from \"openai\";\n\nimport type {\n  Block,\n  ModelEvent,\n  ModelRequest,\n  Msg,\n  StopReason,\n  SystemBlock,\n  ToolSpec,\n  Usage,\n} from \"@alma-harness/core\";\n\n/**\n * Pure translation between Alma's neutral vocabulary (§6.2) and the OpenAI\n * Responses API — spec 003. Side-effect-free; testable without a network.\n */\n\nexport class OpenAITranslationError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"OpenAITranslationError\";\n  }\n}\n\nexport function toOpenAIParams(\n  req: ModelRequest,\n): OpenAI.Responses.ResponseCreateParamsStreaming {\n  if (req.model.provider !== \"openai\") {\n    throw new OpenAITranslationError(\n      `OpenAIModelClient received a request for provider ${JSON.stringify(req.model.provider)}`,\n    );\n  }\n  const params: OpenAI.Responses.ResponseCreateParamsStreaming = {\n    model: req.model.id,\n    max_output_tokens: req.maxTokens,\n    stream: true,\n    // Privacy-first (§3, §10): the Responses API stores responses server-side\n    // by default; the harness never leaves conversation state at the provider.\n    store: false,\n    input: req.messages.flatMap(toInputItems),\n  };\n  const instructions = toInstructions(req.system);\n  if (instructions !== \"\") params.instructions = instructions;\n  if (req.tools.length > 0) params.tools = req.tools.map(toTool);\n  return params;\n}\n\n/**\n * OpenAI has no explicit cache breakpoint (prefix caching is automatic), so\n * the §6.9 stable/volatile discipline is preserved simply by keeping the\n * blocks' order — stable first — in one instructions string.\n */\nfunction toInstructions(blocks: SystemBlock[]): string {\n  return blocks.map((b) => b.text).join(\"\\n\\n\");\n}\n\nfunction toInputItems(msg: Msg): OpenAI.Responses.ResponseInputItem[] {\n  switch (msg.role) {\n    case \"user\":\n      return [{ role: \"user\", content: msg.blocks.map(toUserContentPart) }];\n    case \"assistant\":\n      // Text stays a message item; each tool_call becomes its own top-level\n      // function_call item, preserving block order.\n      return msg.blocks.map(toAssistantItem);\n    case \"tool\":\n      return msg.blocks.map(toFunctionCallOutput);\n  }\n}\n\nfunction toUserContentPart(\n  block: Block,\n): OpenAI.Responses.ResponseInputText | OpenAI.Responses.ResponseInputImage {\n  switch (block.type) {\n    case \"text\":\n      return { type: \"input_text\", text: block.text };\n    case \"media\":\n      if (block.kind === \"image\") {\n        return { type: \"input_image\", detail: \"auto\", image_url: block.ref.uri };\n      }\n      // Documents/audio on the Responses input surface are file-id-centric,\n      // which breaks media-by-reference (§6.1) — fail loudly (spec 003):\n      // the routing policy is the layer that picks capable providers.\n      throw new OpenAITranslationError(\n        `${block.kind} media is not supported by the OpenAI adapter`,\n      );\n    default:\n      throw new OpenAITranslationError(\n        `block type ${JSON.stringify(block.type)} is not valid in a user message`,\n      );\n  }\n}\n\nfunction toAssistantItem(block: Block): OpenAI.Responses.ResponseInputItem {\n  switch (block.type) {\n    case \"text\":\n      return { role: \"assistant\", content: block.text };\n    case \"tool_call\":\n      return {\n        type: \"function_call\",\n        call_id: block.id,\n        name: block.name,\n        arguments: JSON.stringify(block.input),\n      };\n    default:\n      throw new OpenAITranslationError(\n        `block type ${JSON.stringify(block.type)} is not valid in an assistant message`,\n      );\n  }\n}\n\nfunction toFunctionCallOutput(block: Block): OpenAI.Responses.ResponseInputItem {\n  if (block.type !== \"tool_result\") {\n    throw new OpenAITranslationError(\n      `block type ${JSON.stringify(block.type)} is not valid in a tool message`,\n    );\n  }\n  const serialized =\n    typeof block.output === \"string\" ? block.output : (JSON.stringify(block.output) ?? \"null\");\n  return {\n    type: \"function_call_output\",\n    call_id: block.callId,\n    // The Responses API has no is_error flag on function outputs — an\n    // explicit prefix keeps failures visible to the model (spec 003).\n    output: block.isError ? `ERROR: ${serialized}` : serialized,\n  };\n}\n\nfunction toTool(spec: ToolSpec): OpenAI.Responses.FunctionTool {\n  return {\n    type: \"function\",\n    name: spec.name,\n    description: spec.description,\n    parameters: spec.inputSchema,\n    // Registry-derived schemas are not guaranteed strict-compatible; the\n    // structured-output surface is a follow-up slice (spec 003 decision).\n    strict: false,\n  };\n}\n\n/**\n * Semantic stream events → neutral `ModelEvent`s. Function-call arguments\n * arrive complete on `response.output_item.done`, so each call is emitted as\n * ONE parsed `tool_call`. The terminal `response.completed` / `.incomplete`\n * event carries usage; `tool_use` is inferred from having emitted tool calls\n * (the Responses API has no finish_reason).\n */\nexport async function* translateOpenAIStream(\n  events: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>,\n): AsyncGenerator<ModelEvent> {\n  let sawToolCall = false;\n  let sawRefusal = false;\n\n  for await (const event of events) {\n    switch (event.type) {\n      case \"response.output_text.delta\":\n        yield { type: \"text_delta\", text: event.delta };\n        break;\n      case \"response.refusal.delta\":\n        // Refusal content is user-visible text; the stop reason records the\n        // refusal itself (spec 003).\n        sawRefusal = true;\n        yield { type: \"text_delta\", text: event.delta };\n        break;\n      case \"response.output_item.done\":\n        if (event.item.type === \"function_call\") {\n          sawToolCall = true;\n          yield {\n            type: \"tool_call\",\n            id: event.item.call_id,\n            name: event.item.name,\n            input:\n              event.item.arguments === \"\" ? {} : (JSON.parse(event.item.arguments) as unknown),\n          };\n        }\n        break;\n      case \"response.completed\":\n        yield usageEvent(event.response);\n        yield { type: \"stop\", reason: sawRefusal ? \"refusal\" : sawToolCall ? \"tool_use\" : \"end_turn\" };\n        break;\n      case \"response.incomplete\": {\n        yield usageEvent(event.response);\n        yield { type: \"stop\", reason: mapIncompleteReason(event.response) };\n        break;\n      }\n      case \"response.failed\": {\n        const err = event.response.error;\n        throw new OpenAITranslationError(\n          `OpenAI response failed: ${err ? `${err.code}: ${err.message}` : \"unknown error\"}`,\n        );\n      }\n      case \"error\":\n        throw new OpenAITranslationError(`OpenAI stream error: ${event.message}`);\n      default:\n        // created / in_progress / content parts / argument deltas etc. carry\n        // no neutral information beyond the events handled above.\n        break;\n    }\n  }\n}\n\nfunction usageEvent(response: OpenAI.Responses.Response): ModelEvent {\n  const u = response.usage;\n  const cachedRead = u?.input_tokens_details?.cached_tokens ?? 0;\n  const usage: Usage = {\n    // Neutral semantics (spec 005): inputTokens EXCLUDES cache reads.\n    // OpenAI's input_tokens includes cached_tokens; subtract to normalize —\n    // otherwise the BudgetGuard would price the same conversation\n    // differently per provider.\n    inputTokens: Math.max(0, (u?.input_tokens ?? 0) - cachedRead),\n    outputTokens: u?.output_tokens ?? 0,\n  };\n  if (cachedRead > 0) usage.cacheReadInputTokens = cachedRead;\n  const cacheWrite = u?.input_tokens_details?.cache_write_tokens;\n  if (cacheWrite !== undefined && cacheWrite > 0) usage.cacheWriteInputTokens = cacheWrite;\n  return { type: \"usage\", usage };\n}\n\nfunction mapIncompleteReason(response: OpenAI.Responses.Response): StopReason {\n  const reason = response.incomplete_details?.reason;\n  switch (reason) {\n    case \"max_output_tokens\":\n      // NOTE (spec 003 decision): OpenAI's wire conflates context-window\n      // exhaustion into this reason (or a 400 before the stream), so the\n      // neutral \"context_window_exceeded\" is unreachable on this adapter —\n      // the long-context policy must watch provider errors instead.\n      return \"max_tokens\";\n    case \"content_filter\":\n      return \"refusal\";\n    default:\n      throw new OpenAITranslationError(\n        `Unmapped OpenAI incomplete reason ${JSON.stringify(reason)} — provider drift?`,\n      );\n  }\n}\n","import OpenAI from \"openai\";\nimport type { ModelClient, ModelEvent, ModelRequest } from \"@alma-harness/core\";\n\nimport {\n  toOpenRouterParams,\n  translateOpenRouterStream,\n  type OpenRouterParams,\n  type OpenRouterRouting,\n} from \"./translate\";\n\nexport interface OpenRouterModelClientOptions extends OpenRouterRouting {\n  /** Omit to read OPENROUTER_API_KEY (the OpenAI SDK's own env resolution\n   * would read OPENAI_API_KEY — the wrong credential for this gateway). */\n  apiKey?: string;\n  /** Defaults to OpenRouter's public endpoint. */\n  baseURL?: string;\n}\n\nconst OPENROUTER_BASE_URL = \"https://openrouter.ai/api/v1\";\n\n/**\n * `ModelClient` adapter for OpenRouter — §6.2, spec 014 (the gateway bridge).\n * Same thin-shell shape as the first-party adapters: translation lives in\n * ./translate (pure); this class owns the SDK client and the DECLARED\n * upstream policy. A gateway erases \"who processed this data?\" unless the\n * chain is declared beforehand, so construction REFUSES to proceed without a\n * non-empty upstream allowlist — deciding after the fact enforces nothing.\n */\nexport class OpenRouterModelClient implements ModelClient {\n  readonly #client: OpenAI;\n  readonly #routing: OpenRouterRouting;\n\n  constructor(opts: OpenRouterModelClientOptions) {\n    if (!Array.isArray(opts.upstreams) || opts.upstreams.length === 0) {\n      throw new Error(\n        \"OpenRouterModelClient requires a non-empty `upstreams` allowlist — \" +\n          \"for a gateway, the data-processing chain must be a declared fact (spec 014)\",\n      );\n    }\n    const routing: OpenRouterRouting = { upstreams: [...opts.upstreams] };\n    if (opts.allowFallbacks !== undefined) routing.allowFallbacks = opts.allowFallbacks;\n    if (opts.dataCollection !== undefined) routing.dataCollection = opts.dataCollection;\n    if (opts.zeroDataRetention !== undefined) routing.zeroDataRetention = opts.zeroDataRetention;\n    this.#routing = routing;\n\n    const apiKey = opts.apiKey ?? process.env[\"OPENROUTER_API_KEY\"];\n    if (apiKey === undefined || apiKey === \"\") {\n      throw new Error(\n        \"OpenRouterModelClient needs an API key: pass `apiKey` or set OPENROUTER_API_KEY\",\n      );\n    }\n    this.#client = new OpenAI({ apiKey, baseURL: opts.baseURL ?? OPENROUTER_BASE_URL });\n  }\n\n  stream(req: ModelRequest, opts?: { signal?: AbortSignal }): AsyncIterable<ModelEvent> {\n    // Translation throws synchronously (wrong provider, unsupported blocks)\n    // before any network activity, like every adapter in this package.\n    const params = toOpenRouterParams(req, this.#routing);\n    return translateOpenRouterStream(this.#rawChunks(params, opts?.signal));\n  }\n\n  async *#rawChunks(\n    params: OpenRouterParams,\n    signal?: AbortSignal,\n  ): AsyncGenerator<OpenAI.Chat.Completions.ChatCompletionChunk> {\n    const stream = await this.#client.chat.completions.create(\n      params,\n      signal !== undefined ? { signal } : undefined,\n    );\n    for await (const chunk of stream) yield chunk;\n  }\n}\n","import type OpenAI from \"openai\";\n\nimport type {\n  Block,\n  ModelEvent,\n  ModelRequest,\n  Msg,\n  StopReason,\n  SystemBlock,\n  ToolSpec,\n  Usage,\n} from \"@alma-harness/core\";\n\n/**\n * Pure translation between Alma's neutral vocabulary (§6.2) and OpenRouter's\n * chat-completions wire — spec 014. A SECOND translator over the neutral\n * format, not a `baseURL` override: the first-party OpenAI adapter speaks the\n * Responses API, and nothing in its translation is reusable here.\n * Side-effect-free; testable without a network.\n */\n\nexport class OpenRouterTranslationError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"OpenRouterTranslationError\";\n  }\n}\n\n/**\n * The upstream routing policy — spec 014's core constraint: for a gateway,\n * \"who processed this data?\" must be a DECLARED fact, not an observed one.\n */\nexport interface OpenRouterRouting {\n  /**\n   * OpenRouter provider slugs allowed to serve requests (→ `provider.only`).\n   * REQUIRED and non-empty: without it the data-processing chain has no\n   * answer, so the client refuses to construct.\n   */\n  upstreams: readonly string[];\n  /**\n   * Default false: a fallback is a silent change of data processor. Enabling\n   * it is a stated product choice, never a default.\n   */\n  allowFallbacks?: boolean;\n  /**\n   * Default \"deny\" — OpenRouter defaults to \"allow\", and a harness whose\n   * README says \"operating on sensitive data\" must not inherit the permissive\n   * default (spec 014 DECISION).\n   */\n  dataCollection?: \"allow\" | \"deny\";\n  /** Opt-in pass-through to OpenRouter's zero-data-retention guarantee. */\n  zeroDataRetention?: boolean;\n}\n\n/** The `provider` routing block OpenRouter accepts on every request. */\ninterface OpenRouterProviderBlock {\n  only: string[];\n  allow_fallbacks: boolean;\n  data_collection: \"allow\" | \"deny\";\n  zdr?: boolean;\n  require_parameters?: boolean;\n}\n\nexport type OpenRouterParams = OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming & {\n  provider: OpenRouterProviderBlock;\n};\n\nexport function toOpenRouterParams(req: ModelRequest, routing: OpenRouterRouting): OpenRouterParams {\n  if (req.model.provider !== \"openrouter\") {\n    throw new OpenRouterTranslationError(\n      `OpenRouterModelClient received a request for provider ${JSON.stringify(req.model.provider)}`,\n    );\n  }\n  const provider: OpenRouterProviderBlock = {\n    only: [...routing.upstreams],\n    allow_fallbacks: routing.allowFallbacks ?? false,\n    data_collection: routing.dataCollection ?? \"deny\",\n  };\n  if (routing.zeroDataRetention === true) provider.zdr = true;\n  if (req.tools.length > 0) {\n    // Not cosmetic (spec 014): tool support varies by upstream, and without\n    // this a model can receive the request WITHOUT the tools it was supposed\n    // to have — a silent capability failure for a loop whose control flow IS\n    // tool calls.\n    provider.require_parameters = true;\n  }\n\n  const params: OpenRouterParams = {\n    model: req.model.id,\n    // The SDK deprecates this in favor of the OpenAI-specific\n    // max_completion_tokens; for a gateway fronting heterogeneous upstreams,\n    // max_tokens is the common denominator OpenRouter documents.\n    max_tokens: req.maxTokens,\n    stream: true,\n    // Review amendment (spec 014): streamed chat completions only carry usage\n    // when asked — without this the BudgetGuard never sees a usage event.\n    stream_options: { include_usage: true },\n    messages: [...systemMessages(req.system), ...req.messages.flatMap(toWireMessages)],\n    provider,\n  };\n  if (req.tools.length > 0) params.tools = req.tools.map(toTool);\n  return params;\n}\n\n/**\n * Chat completions has no instructions field; system blocks become one system\n * message. The §6.9 stable/volatile discipline is preserved by keeping the\n * blocks' order — stable first — exactly as the OpenAI adapter does; whether\n * an upstream caches the prefix varies (spec 014's cache-hygiene note).\n */\nfunction systemMessages(\n  blocks: SystemBlock[],\n): OpenAI.Chat.Completions.ChatCompletionMessageParam[] {\n  if (blocks.length === 0) return [];\n  return [{ role: \"system\", content: blocks.map((b) => b.text).join(\"\\n\\n\") }];\n}\n\nfunction toWireMessages(msg: Msg): OpenAI.Chat.Completions.ChatCompletionMessageParam[] {\n  switch (msg.role) {\n    case \"user\":\n      return [{ role: \"user\", content: msg.blocks.map(toUserContentPart) }];\n    case \"assistant\":\n      return [toAssistantMessage(msg.blocks)];\n    case \"tool\":\n      // Chat completions wants one tool-role message PER result, keyed by\n      // tool_call_id — unlike Anthropic's single user message of results.\n      return msg.blocks.map(toToolMessage);\n  }\n}\n\nfunction toUserContentPart(block: Block): OpenAI.Chat.Completions.ChatCompletionContentPart {\n  switch (block.type) {\n    case \"text\":\n      return { type: \"text\", text: block.text };\n    case \"media\":\n      if (block.kind === \"image\") {\n        return { type: \"image_url\", image_url: { url: block.ref.uri } };\n      }\n      // Document/audio support varies wildly by upstream and the wire shapes\n      // are provider-specific — fail loudly (the routing policy is the layer\n      // that picks capable providers, spec 003's precedent).\n      throw new OpenRouterTranslationError(\n        `${block.kind} media is not supported by the OpenRouter adapter`,\n      );\n    default:\n      throw new OpenRouterTranslationError(\n        `block type ${JSON.stringify(block.type)} is not valid in a user message`,\n      );\n  }\n}\n\nfunction toAssistantMessage(blocks: Block[]): OpenAI.Chat.Completions.ChatCompletionMessageParam {\n  let text = \"\";\n  const toolCalls: OpenAI.Chat.Completions.ChatCompletionMessageToolCall[] = [];\n  for (const block of blocks) {\n    switch (block.type) {\n      case \"text\":\n        text += block.text;\n        break;\n      case \"tool_call\":\n        toolCalls.push({\n          id: block.id,\n          type: \"function\",\n          function: { name: block.name, arguments: JSON.stringify(block.input) },\n        });\n        break;\n      default:\n        throw new OpenRouterTranslationError(\n          `block type ${JSON.stringify(block.type)} is not valid in an assistant message`,\n        );\n    }\n  }\n  const message: OpenAI.Chat.Completions.ChatCompletionAssistantMessageParam = {\n    role: \"assistant\",\n    content: text === \"\" ? null : text,\n  };\n  if (toolCalls.length > 0) message.tool_calls = toolCalls;\n  return message;\n}\n\nfunction toToolMessage(block: Block): OpenAI.Chat.Completions.ChatCompletionMessageParam {\n  if (block.type !== \"tool_result\") {\n    throw new OpenRouterTranslationError(\n      `block type ${JSON.stringify(block.type)} is not valid in a tool message`,\n    );\n  }\n  const serialized =\n    typeof block.output === \"string\" ? block.output : (JSON.stringify(block.output) ?? \"null\");\n  return {\n    role: \"tool\",\n    tool_call_id: block.callId,\n    // No is_error flag on this wire either — the explicit prefix keeps\n    // failures visible to the model (spec 003's precedent).\n    content: block.isError ? `ERROR: ${serialized}` : serialized,\n  };\n}\n\nfunction toTool(spec: ToolSpec): OpenAI.Chat.Completions.ChatCompletionTool {\n  return {\n    type: \"function\",\n    function: {\n      name: spec.name,\n      description: spec.description,\n      parameters: spec.inputSchema,\n    },\n  };\n}\n\n/**\n * Chat-completion chunks → neutral `ModelEvent`s. Tool-call arguments arrive\n * as indexed fragments (id and name on the first fragment, argument pieces on\n * the rest); they are accumulated per index and emitted as ONE parsed\n * `tool_call` each when the choice finishes. The usage chunk arrives AFTER\n * `finish_reason` (with `stream_options.include_usage`), so the terminal\n * usage + stop pair is emitted at stream end — same order every adapter emits.\n */\nexport async function* translateOpenRouterStream(\n  chunks: AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>,\n): AsyncGenerator<ModelEvent> {\n  const pendingTools = new Map<number, { id: string; name: string; json: string }>();\n  let finish: string | null = null;\n  let usage: Usage | null = null;\n  let toolsEmitted = false;\n\n  for await (const chunk of chunks) {\n    const choice = chunk.choices[0];\n    if (choice) {\n      if (choice.delta.content != null && choice.delta.content !== \"\") {\n        yield { type: \"text_delta\", text: choice.delta.content };\n      }\n      for (const fragment of choice.delta.tool_calls ?? []) {\n        const pending = pendingTools.get(fragment.index) ?? { id: \"\", name: \"\", json: \"\" };\n        if (fragment.id != null) pending.id = fragment.id;\n        if (fragment.function?.name != null) pending.name = fragment.function.name;\n        if (fragment.function?.arguments != null) pending.json += fragment.function.arguments;\n        pendingTools.set(fragment.index, pending);\n      }\n      if (choice.finish_reason != null) {\n        finish = choice.finish_reason;\n        if (!toolsEmitted) {\n          toolsEmitted = true;\n          for (const [, call] of [...pendingTools.entries()].sort(([a], [b]) => a - b)) {\n            yield {\n              type: \"tool_call\",\n              id: call.id,\n              name: call.name,\n              input: call.json === \"\" ? {} : (JSON.parse(call.json) as unknown),\n            };\n          }\n          pendingTools.clear();\n        }\n      }\n    }\n    if (chunk.usage != null) {\n      const cachedRead = chunk.usage.prompt_tokens_details?.cached_tokens ?? 0;\n      usage = {\n        // Neutral semantics (spec 005): inputTokens EXCLUDES cache reads —\n        // the wire's prompt_tokens includes them.\n        inputTokens: Math.max(0, chunk.usage.prompt_tokens - cachedRead),\n        outputTokens: chunk.usage.completion_tokens,\n      };\n      if (cachedRead > 0) usage.cacheReadInputTokens = cachedRead;\n      // No cache-write signal exists on this wire; the field stays absent.\n    }\n  }\n\n  if (finish === null) {\n    throw new OpenRouterTranslationError(\n      \"OpenRouter stream ended without a finish_reason — provider drift?\",\n    );\n  }\n  if (usage !== null) yield { type: \"usage\", usage };\n  yield { type: \"stop\", reason: mapFinishReason(finish) };\n}\n\nfunction mapFinishReason(reason: string): StopReason {\n  switch (reason) {\n    case \"stop\":\n      return \"end_turn\";\n    case \"tool_calls\":\n      return \"tool_use\";\n    case \"length\":\n      return \"max_tokens\";\n    case \"content_filter\":\n      return \"refusal\";\n    default:\n      // \"error\", or a reason newer than this adapter: refuse loudly rather\n      // than silently truncate. NOTE (spec 014 review amendment): context-\n      // window overflow arrives as a 400 error before any stream, so the\n      // neutral \"context_window_exceeded\" is unreachable on this wire — the\n      // long-context policy must watch provider errors, as with the OpenAI\n      // adapter.\n      throw new OpenRouterTranslationError(\n        `Unmapped OpenRouter finish_reason ${JSON.stringify(reason)} — provider drift?`,\n      );\n  }\n}\n","import type { ProviderId } from \"@alma-harness/core\";\n\n/**\n * @alma-harness/providers — `ModelClient` adapters (§6.2).\n * Bi-provider from birth — `AnthropicModelClient` (spec 002) and\n * `OpenAIModelClient` (spec 003) — plus the OpenRouter gateway bridge\n * (spec 014), all over the same neutral surface.\n */\n\nexport { AnthropicModelClient } from \"./anthropic/client\";\nexport type { AnthropicModelClientOptions } from \"./anthropic/client\";\nexport {\n  AnthropicTranslationError,\n  toAnthropicParams,\n  translateStream,\n} from \"./anthropic/translate\";\n\nexport { OpenAIModelClient } from \"./openai/client\";\nexport type { OpenAIModelClientOptions } from \"./openai/client\";\nexport {\n  OpenAITranslationError,\n  toOpenAIParams,\n  translateOpenAIStream,\n} from \"./openai/translate\";\n\nexport { OpenRouterModelClient } from \"./openrouter/client\";\nexport type { OpenRouterModelClientOptions } from \"./openrouter/client\";\nexport {\n  OpenRouterTranslationError,\n  toOpenRouterParams,\n  translateOpenRouterStream,\n} from \"./openrouter/translate\";\nexport type { OpenRouterParams, OpenRouterRouting } from \"./openrouter/translate\";\n\nexport type { ModelClient, ModelEvent, ModelRef, ModelRequest, ProviderId } from \"@alma-harness/core\";\n\n/**\n * First-party from birth (§3 principle 4), plus the gateway bridge —\n * spec 014: `openrouter` names the EXIT, not the processor; its adapter\n * requires a declared upstream allowlist for exactly that reason.\n */\nexport const SUPPORTED_PROVIDERS = [\"anthropic\", \"openai\", \"openrouter\"] as const satisfies readonly ProviderId[];\n"],"mappings":";AAAA,OAAO,eAAe;;;ACoBf,IAAM,4BAAN,cAAwC,MAAM;AAAA,EACnD,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEO,SAAS,kBAAkB,KAA2D;AAC3F,MAAI,IAAI,MAAM,aAAa,aAAa;AACtC,UAAM,IAAI;AAAA,MACR,wDAAwD,KAAK,UAAU,IAAI,MAAM,QAAQ,CAAC;AAAA,IAC5F;AAAA,EACF;AACA,QAAM,SAAiD;AAAA,IACrD,OAAO,IAAI,MAAM;AAAA,IACjB,YAAY,IAAI;AAAA,IAChB,QAAQ;AAAA,IACR,QAAQ,SAAS,IAAI,MAAM;AAAA,IAC3B,UAAU,IAAI,SAAS,IAAI,cAAc;AAAA,EAC3C;AACA,MAAI,IAAI,MAAM,SAAS,EAAG,QAAO,QAAQ,IAAI,MAAM,IAAI,MAAM;AAC7D,uBAAqB,OAAO,QAAQ;AACpC,SAAO;AACT;AAQA,SAAS,qBAAqB,UAA0C;AACtE,QAAM,OAAO,SAAS,GAAG,EAAE;AAC3B,MAAI,CAAC,QAAQ,OAAO,KAAK,YAAY,SAAU;AAC/C,QAAM,QAAQ,KAAK,QAAQ,GAAG,EAAE;AAChC,MAAI,MAAO,CAAC,MAA8D,gBAAgB,EAAE,MAAM,YAAY;AAChH;AAOA,SAAS,SAAS,QAAmD;AACnE,QAAM,aAAa,OAAO;AAAA,IACxB,CAAC,MAAM,GAAG,MAAO,EAAE,eAAe,WAAW,IAAI;AAAA,IACjD;AAAA,EACF;AACA,SAAO,OAAO,IAAI,CAAC,GAAG,MAAM;AAC1B,UAAM,QAAkC,EAAE,MAAM,QAAQ,MAAM,EAAE,KAAK;AACrE,QAAI,MAAM,WAAY,OAAM,gBAAgB,EAAE,MAAM,YAAY;AAChE,WAAO;AAAA,EACT,CAAC;AACH;AAEA,SAAS,eAAe,KAAkC;AACxD,UAAQ,IAAI,MAAM;AAAA,IAChB,KAAK;AACH,aAAO,EAAE,MAAM,QAAQ,SAAS,IAAI,OAAO,IAAI,WAAW,EAAE;AAAA,IAC9D,KAAK;AACH,aAAO,EAAE,MAAM,aAAa,SAAS,IAAI,OAAO,IAAI,gBAAgB,EAAE;AAAA,IACxE,KAAK;AAEH,aAAO,EAAE,MAAM,QAAQ,SAAS,IAAI,OAAO,IAAI,iBAAiB,EAAE;AAAA,EACtE;AACF;AAEA,SAAS,YAAY,OAA2C;AAC9D,UAAQ,MAAM,MAAM;AAAA,IAClB,KAAK;AACH,aAAO,EAAE,MAAM,QAAQ,MAAM,MAAM,KAAK;AAAA,IAC1C,KAAK;AACH,cAAQ,MAAM,MAAM;AAAA,QAClB,KAAK;AACH,iBAAO,EAAE,MAAM,SAAS,QAAQ,EAAE,MAAM,OAAO,KAAK,MAAM,IAAI,IAAI,EAAE;AAAA,QACtE,KAAK;AACH,iBAAO,EAAE,MAAM,YAAY,QAAQ,EAAE,MAAM,OAAO,KAAK,MAAM,IAAI,IAAI,EAAE;AAAA,QACzE,KAAK;AAEH,gBAAM,IAAI,0BAA0B,uDAAuD;AAAA,MAC/F;AAAA,IACF;AACE,YAAM,IAAI,0BAA0B,cAAc,KAAK,UAAU,MAAM,IAAI,CAAC,iCAAiC;AAAA,EACjH;AACF;AAEA,SAAS,iBAAiB,OAA2C;AACnE,UAAQ,MAAM,MAAM;AAAA,IAClB,KAAK;AACH,aAAO,EAAE,MAAM,QAAQ,MAAM,MAAM,KAAK;AAAA,IAC1C,KAAK;AACH,aAAO,EAAE,MAAM,YAAY,IAAI,MAAM,IAAI,MAAM,MAAM,MAAM,OAAO,MAAM,MAAM;AAAA,IAChF;AACE,YAAM,IAAI;AAAA,QACR,cAAc,KAAK,UAAU,MAAM,IAAI,CAAC;AAAA,MAC1C;AAAA,EACJ;AACF;AAEA,SAAS,kBAAkB,OAA8C;AACvE,MAAI,MAAM,SAAS,eAAe;AAChC,UAAM,IAAI;AAAA,MACR,cAAc,KAAK,UAAU,MAAM,IAAI,CAAC;AAAA,IAC1C;AAAA,EACF;AACA,QAAM,QAAwC;AAAA,IAC5C,MAAM;AAAA,IACN,aAAa,MAAM;AAAA;AAAA;AAAA,IAGnB,SACE,OAAO,MAAM,WAAW,WAAW,MAAM,SAAU,KAAK,UAAU,MAAM,MAAM,KAAK;AAAA,EACvF;AACA,MAAI,MAAM,QAAS,OAAM,WAAW;AACpC,SAAO;AACT;AAEA,SAAS,OAAO,MAAgC;AAC9C,SAAO;AAAA,IACL,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA;AAAA,IAElB,cAAc,KAAK;AAAA,EACrB;AACF;AASA,gBAAuB,gBACrB,QAC4B;AAC5B,QAAM,QAAe,EAAE,aAAa,GAAG,cAAc,EAAE;AACvD,MAAI,aAA+C;AACnD,QAAM,eAAe,oBAAI,IAAwD;AAEjF,mBAAiB,SAAS,QAAQ;AAChC,YAAQ,MAAM,MAAM;AAAA,MAClB,KAAK,iBAAiB;AACpB,cAAM,IAAI,MAAM,QAAQ;AACxB,cAAM,cAAc,EAAE;AACtB,YAAI,EAAE,2BAA2B,KAAM,OAAM,uBAAuB,EAAE;AACtE,YAAI,EAAE,+BAA+B,MAAM;AACzC,gBAAM,wBAAwB,EAAE;AAAA,QAClC;AACA;AAAA,MACF;AAAA,MACA,KAAK;AACH,YAAI,MAAM,cAAc,SAAS,YAAY;AAC3C,uBAAa,IAAI,MAAM,OAAO;AAAA,YAC5B,IAAI,MAAM,cAAc;AAAA,YACxB,MAAM,MAAM,cAAc;AAAA,YAC1B,MAAM;AAAA,UACR,CAAC;AAAA,QACH;AACA;AAAA,MACF,KAAK;AACH,YAAI,MAAM,MAAM,SAAS,cAAc;AACrC,gBAAM,EAAE,MAAM,cAAc,MAAM,MAAM,MAAM,KAAK;AAAA,QACrD,WAAW,MAAM,MAAM,SAAS,oBAAoB;AAClD,gBAAM,UAAU,aAAa,IAAI,MAAM,KAAK;AAC5C,cAAI,QAAS,SAAQ,QAAQ,MAAM,MAAM;AAAA,QAC3C;AACA;AAAA,MACF,KAAK,sBAAsB;AACzB,cAAM,UAAU,aAAa,IAAI,MAAM,KAAK;AAC5C,YAAI,SAAS;AACX,uBAAa,OAAO,MAAM,KAAK;AAC/B,gBAAM;AAAA,YACJ,MAAM;AAAA,YACN,IAAI,QAAQ;AAAA,YACZ,MAAM,QAAQ;AAAA,YACd,OAAO,QAAQ,SAAS,KAAK,CAAC,IAAK,KAAK,MAAM,QAAQ,IAAI;AAAA,UAC5D;AAAA,QACF;AACA;AAAA,MACF;AAAA,MACA,KAAK;AACH,YAAI,MAAM,MAAM,eAAe,KAAM,cAAa,MAAM,MAAM;AAC9D,cAAM,eAAe,MAAM,MAAM;AACjC;AAAA,MACF,KAAK;AACH,cAAM,EAAE,MAAM,SAAS,OAAO,EAAE,GAAG,MAAM,EAAE;AAC3C,cAAM,EAAE,MAAM,QAAQ,QAAQ,cAAc,UAAU,EAAE;AACxD;AAAA,IACJ;AAAA,EACF;AACF;AAEA,SAAS,cAAc,QAAsD;AAC3E,UAAQ,QAAQ;AAAA,IACd,KAAK;AAAA,IACL,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT;AAIE,YAAM,IAAI;AAAA,QACR,kCAAkC,KAAK,UAAU,MAAM,CAAC;AAAA,MAC1D;AAAA,EACJ;AACF;;;AD1NO,IAAM,uBAAN,MAAkD;AAAA,EAC9C;AAAA,EAET,YAAY,OAAoC,CAAC,GAAG;AAClD,UAAM,OAAmD,CAAC;AAC1D,QAAI,KAAK,WAAW,OAAW,MAAK,SAAS,KAAK;AAClD,QAAI,KAAK,YAAY,OAAW,MAAK,UAAU,KAAK;AACpD,SAAK,UAAU,IAAI,UAAU,IAAI;AAAA,EACnC;AAAA,EAEA,OAAO,KAAmB,MAA4D;AAGpF,UAAM,SAAS,kBAAkB,GAAG;AACpC,WAAO,gBAAgB,KAAK,WAAW,QAAQ,MAAM,MAAM,CAAC;AAAA,EAC9D;AAAA,EAEA,OAAO,WACL,QACA,QACiD;AACjD,UAAM,SAAS,MAAM,KAAK,QAAQ,SAAS;AAAA,MACzC;AAAA,MACA,WAAW,SAAY,EAAE,OAAO,IAAI;AAAA,IACtC;AACA,qBAAiB,SAAS,OAAQ,OAAM;AAAA,EAC1C;AACF;;;AE3CA,OAAO,YAAY;;;ACkBZ,IAAM,yBAAN,cAAqC,MAAM;AAAA,EAChD,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEO,SAAS,eACd,KACgD;AAChD,MAAI,IAAI,MAAM,aAAa,UAAU;AACnC,UAAM,IAAI;AAAA,MACR,qDAAqD,KAAK,UAAU,IAAI,MAAM,QAAQ,CAAC;AAAA,IACzF;AAAA,EACF;AACA,QAAM,SAAyD;AAAA,IAC7D,OAAO,IAAI,MAAM;AAAA,IACjB,mBAAmB,IAAI;AAAA,IACvB,QAAQ;AAAA;AAAA;AAAA,IAGR,OAAO;AAAA,IACP,OAAO,IAAI,SAAS,QAAQ,YAAY;AAAA,EAC1C;AACA,QAAM,eAAe,eAAe,IAAI,MAAM;AAC9C,MAAI,iBAAiB,GAAI,QAAO,eAAe;AAC/C,MAAI,IAAI,MAAM,SAAS,EAAG,QAAO,QAAQ,IAAI,MAAM,IAAIA,OAAM;AAC7D,SAAO;AACT;AAOA,SAAS,eAAe,QAA+B;AACrD,SAAO,OAAO,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,MAAM;AAC9C;AAEA,SAAS,aAAa,KAAgD;AACpE,UAAQ,IAAI,MAAM;AAAA,IAChB,KAAK;AACH,aAAO,CAAC,EAAE,MAAM,QAAQ,SAAS,IAAI,OAAO,IAAI,iBAAiB,EAAE,CAAC;AAAA,IACtE,KAAK;AAGH,aAAO,IAAI,OAAO,IAAI,eAAe;AAAA,IACvC,KAAK;AACH,aAAO,IAAI,OAAO,IAAI,oBAAoB;AAAA,EAC9C;AACF;AAEA,SAAS,kBACP,OAC0E;AAC1E,UAAQ,MAAM,MAAM;AAAA,IAClB,KAAK;AACH,aAAO,EAAE,MAAM,cAAc,MAAM,MAAM,KAAK;AAAA,IAChD,KAAK;AACH,UAAI,MAAM,SAAS,SAAS;AAC1B,eAAO,EAAE,MAAM,eAAe,QAAQ,QAAQ,WAAW,MAAM,IAAI,IAAI;AAAA,MACzE;AAIA,YAAM,IAAI;AAAA,QACR,GAAG,MAAM,IAAI;AAAA,MACf;AAAA,IACF;AACE,YAAM,IAAI;AAAA,QACR,cAAc,KAAK,UAAU,MAAM,IAAI,CAAC;AAAA,MAC1C;AAAA,EACJ;AACF;AAEA,SAAS,gBAAgB,OAAkD;AACzE,UAAQ,MAAM,MAAM;AAAA,IAClB,KAAK;AACH,aAAO,EAAE,MAAM,aAAa,SAAS,MAAM,KAAK;AAAA,IAClD,KAAK;AACH,aAAO;AAAA,QACL,MAAM;AAAA,QACN,SAAS,MAAM;AAAA,QACf,MAAM,MAAM;AAAA,QACZ,WAAW,KAAK,UAAU,MAAM,KAAK;AAAA,MACvC;AAAA,IACF;AACE,YAAM,IAAI;AAAA,QACR,cAAc,KAAK,UAAU,MAAM,IAAI,CAAC;AAAA,MAC1C;AAAA,EACJ;AACF;AAEA,SAAS,qBAAqB,OAAkD;AAC9E,MAAI,MAAM,SAAS,eAAe;AAChC,UAAM,IAAI;AAAA,MACR,cAAc,KAAK,UAAU,MAAM,IAAI,CAAC;AAAA,IAC1C;AAAA,EACF;AACA,QAAM,aACJ,OAAO,MAAM,WAAW,WAAW,MAAM,SAAU,KAAK,UAAU,MAAM,MAAM,KAAK;AACrF,SAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS,MAAM;AAAA;AAAA;AAAA,IAGf,QAAQ,MAAM,UAAU,UAAU,UAAU,KAAK;AAAA,EACnD;AACF;AAEA,SAASA,QAAO,MAA+C;AAC7D,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA,IAClB,YAAY,KAAK;AAAA;AAAA;AAAA,IAGjB,QAAQ;AAAA,EACV;AACF;AASA,gBAAuB,sBACrB,QAC4B;AAC5B,MAAI,cAAc;AAClB,MAAI,aAAa;AAEjB,mBAAiB,SAAS,QAAQ;AAChC,YAAQ,MAAM,MAAM;AAAA,MAClB,KAAK;AACH,cAAM,EAAE,MAAM,cAAc,MAAM,MAAM,MAAM;AAC9C;AAAA,MACF,KAAK;AAGH,qBAAa;AACb,cAAM,EAAE,MAAM,cAAc,MAAM,MAAM,MAAM;AAC9C;AAAA,MACF,KAAK;AACH,YAAI,MAAM,KAAK,SAAS,iBAAiB;AACvC,wBAAc;AACd,gBAAM;AAAA,YACJ,MAAM;AAAA,YACN,IAAI,MAAM,KAAK;AAAA,YACf,MAAM,MAAM,KAAK;AAAA,YACjB,OACE,MAAM,KAAK,cAAc,KAAK,CAAC,IAAK,KAAK,MAAM,MAAM,KAAK,SAAS;AAAA,UACvE;AAAA,QACF;AACA;AAAA,MACF,KAAK;AACH,cAAM,WAAW,MAAM,QAAQ;AAC/B,cAAM,EAAE,MAAM,QAAQ,QAAQ,aAAa,YAAY,cAAc,aAAa,WAAW;AAC7F;AAAA,MACF,KAAK,uBAAuB;AAC1B,cAAM,WAAW,MAAM,QAAQ;AAC/B,cAAM,EAAE,MAAM,QAAQ,QAAQ,oBAAoB,MAAM,QAAQ,EAAE;AAClE;AAAA,MACF;AAAA,MACA,KAAK,mBAAmB;AACtB,cAAM,MAAM,MAAM,SAAS;AAC3B,cAAM,IAAI;AAAA,UACR,2BAA2B,MAAM,GAAG,IAAI,IAAI,KAAK,IAAI,OAAO,KAAK,eAAe;AAAA,QAClF;AAAA,MACF;AAAA,MACA,KAAK;AACH,cAAM,IAAI,uBAAuB,wBAAwB,MAAM,OAAO,EAAE;AAAA,MAC1E;AAGE;AAAA,IACJ;AAAA,EACF;AACF;AAEA,SAAS,WAAW,UAAiD;AACnE,QAAM,IAAI,SAAS;AACnB,QAAM,aAAa,GAAG,sBAAsB,iBAAiB;AAC7D,QAAM,QAAe;AAAA;AAAA;AAAA;AAAA;AAAA,IAKnB,aAAa,KAAK,IAAI,IAAI,GAAG,gBAAgB,KAAK,UAAU;AAAA,IAC5D,cAAc,GAAG,iBAAiB;AAAA,EACpC;AACA,MAAI,aAAa,EAAG,OAAM,uBAAuB;AACjD,QAAM,aAAa,GAAG,sBAAsB;AAC5C,MAAI,eAAe,UAAa,aAAa,EAAG,OAAM,wBAAwB;AAC9E,SAAO,EAAE,MAAM,SAAS,MAAM;AAChC;AAEA,SAAS,oBAAoB,UAAiD;AAC5E,QAAM,SAAS,SAAS,oBAAoB;AAC5C,UAAQ,QAAQ;AAAA,IACd,KAAK;AAKH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT;AACE,YAAM,IAAI;AAAA,QACR,qCAAqC,KAAK,UAAU,MAAM,CAAC;AAAA,MAC7D;AAAA,EACJ;AACF;;;AD1NO,IAAM,oBAAN,MAA+C;AAAA,EAC3C;AAAA,EAET,YAAY,OAAiC,CAAC,GAAG;AAC/C,UAAM,OAAgD,CAAC;AACvD,QAAI,KAAK,WAAW,OAAW,MAAK,SAAS,KAAK;AAClD,QAAI,KAAK,YAAY,OAAW,MAAK,UAAU,KAAK;AACpD,SAAK,UAAU,IAAI,OAAO,IAAI;AAAA,EAChC;AAAA,EAEA,OAAO,KAAmB,MAA4D;AAGpF,UAAM,SAAS,eAAe,GAAG;AACjC,WAAO,sBAAsB,KAAK,WAAW,QAAQ,MAAM,MAAM,CAAC;AAAA,EACpE;AAAA,EAEA,OAAO,WACL,QACA,QACsD;AACtD,UAAM,SAAS,MAAM,KAAK,QAAQ,UAAU;AAAA,MAC1C;AAAA,MACA,WAAW,SAAY,EAAE,OAAO,IAAI;AAAA,IACtC;AACA,qBAAiB,SAAS,OAAQ,OAAM;AAAA,EAC1C;AACF;;;AE3CA,OAAOC,aAAY;;;ACqBZ,IAAM,6BAAN,cAAyC,MAAM;AAAA,EACpD,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAyCO,SAAS,mBAAmB,KAAmB,SAA8C;AAClG,MAAI,IAAI,MAAM,aAAa,cAAc;AACvC,UAAM,IAAI;AAAA,MACR,yDAAyD,KAAK,UAAU,IAAI,MAAM,QAAQ,CAAC;AAAA,IAC7F;AAAA,EACF;AACA,QAAM,WAAoC;AAAA,IACxC,MAAM,CAAC,GAAG,QAAQ,SAAS;AAAA,IAC3B,iBAAiB,QAAQ,kBAAkB;AAAA,IAC3C,iBAAiB,QAAQ,kBAAkB;AAAA,EAC7C;AACA,MAAI,QAAQ,sBAAsB,KAAM,UAAS,MAAM;AACvD,MAAI,IAAI,MAAM,SAAS,GAAG;AAKxB,aAAS,qBAAqB;AAAA,EAChC;AAEA,QAAM,SAA2B;AAAA,IAC/B,OAAO,IAAI,MAAM;AAAA;AAAA;AAAA;AAAA,IAIjB,YAAY,IAAI;AAAA,IAChB,QAAQ;AAAA;AAAA;AAAA,IAGR,gBAAgB,EAAE,eAAe,KAAK;AAAA,IACtC,UAAU,CAAC,GAAG,eAAe,IAAI,MAAM,GAAG,GAAG,IAAI,SAAS,QAAQ,cAAc,CAAC;AAAA,IACjF;AAAA,EACF;AACA,MAAI,IAAI,MAAM,SAAS,EAAG,QAAO,QAAQ,IAAI,MAAM,IAAIC,OAAM;AAC7D,SAAO;AACT;AAQA,SAAS,eACP,QACsD;AACtD,MAAI,OAAO,WAAW,EAAG,QAAO,CAAC;AACjC,SAAO,CAAC,EAAE,MAAM,UAAU,SAAS,OAAO,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,MAAM,EAAE,CAAC;AAC7E;AAEA,SAAS,eAAe,KAAgE;AACtF,UAAQ,IAAI,MAAM;AAAA,IAChB,KAAK;AACH,aAAO,CAAC,EAAE,MAAM,QAAQ,SAAS,IAAI,OAAO,IAAIC,kBAAiB,EAAE,CAAC;AAAA,IACtE,KAAK;AACH,aAAO,CAAC,mBAAmB,IAAI,MAAM,CAAC;AAAA,IACxC,KAAK;AAGH,aAAO,IAAI,OAAO,IAAI,aAAa;AAAA,EACvC;AACF;AAEA,SAASA,mBAAkB,OAAiE;AAC1F,UAAQ,MAAM,MAAM;AAAA,IAClB,KAAK;AACH,aAAO,EAAE,MAAM,QAAQ,MAAM,MAAM,KAAK;AAAA,IAC1C,KAAK;AACH,UAAI,MAAM,SAAS,SAAS;AAC1B,eAAO,EAAE,MAAM,aAAa,WAAW,EAAE,KAAK,MAAM,IAAI,IAAI,EAAE;AAAA,MAChE;AAIA,YAAM,IAAI;AAAA,QACR,GAAG,MAAM,IAAI;AAAA,MACf;AAAA,IACF;AACE,YAAM,IAAI;AAAA,QACR,cAAc,KAAK,UAAU,MAAM,IAAI,CAAC;AAAA,MAC1C;AAAA,EACJ;AACF;AAEA,SAAS,mBAAmB,QAAqE;AAC/F,MAAI,OAAO;AACX,QAAM,YAAqE,CAAC;AAC5E,aAAW,SAAS,QAAQ;AAC1B,YAAQ,MAAM,MAAM;AAAA,MAClB,KAAK;AACH,gBAAQ,MAAM;AACd;AAAA,MACF,KAAK;AACH,kBAAU,KAAK;AAAA,UACb,IAAI,MAAM;AAAA,UACV,MAAM;AAAA,UACN,UAAU,EAAE,MAAM,MAAM,MAAM,WAAW,KAAK,UAAU,MAAM,KAAK,EAAE;AAAA,QACvE,CAAC;AACD;AAAA,MACF;AACE,cAAM,IAAI;AAAA,UACR,cAAc,KAAK,UAAU,MAAM,IAAI,CAAC;AAAA,QAC1C;AAAA,IACJ;AAAA,EACF;AACA,QAAM,UAAuE;AAAA,IAC3E,MAAM;AAAA,IACN,SAAS,SAAS,KAAK,OAAO;AAAA,EAChC;AACA,MAAI,UAAU,SAAS,EAAG,SAAQ,aAAa;AAC/C,SAAO;AACT;AAEA,SAAS,cAAc,OAAkE;AACvF,MAAI,MAAM,SAAS,eAAe;AAChC,UAAM,IAAI;AAAA,MACR,cAAc,KAAK,UAAU,MAAM,IAAI,CAAC;AAAA,IAC1C;AAAA,EACF;AACA,QAAM,aACJ,OAAO,MAAM,WAAW,WAAW,MAAM,SAAU,KAAK,UAAU,MAAM,MAAM,KAAK;AACrF,SAAO;AAAA,IACL,MAAM;AAAA,IACN,cAAc,MAAM;AAAA;AAAA;AAAA,IAGpB,SAAS,MAAM,UAAU,UAAU,UAAU,KAAK;AAAA,EACpD;AACF;AAEA,SAASD,QAAO,MAA4D;AAC1E,SAAO;AAAA,IACL,MAAM;AAAA,IACN,UAAU;AAAA,MACR,MAAM,KAAK;AAAA,MACX,aAAa,KAAK;AAAA,MAClB,YAAY,KAAK;AAAA,IACnB;AAAA,EACF;AACF;AAUA,gBAAuB,0BACrB,QAC4B;AAC5B,QAAM,eAAe,oBAAI,IAAwD;AACjF,MAAI,SAAwB;AAC5B,MAAI,QAAsB;AAC1B,MAAI,eAAe;AAEnB,mBAAiB,SAAS,QAAQ;AAChC,UAAM,SAAS,MAAM,QAAQ,CAAC;AAC9B,QAAI,QAAQ;AACV,UAAI,OAAO,MAAM,WAAW,QAAQ,OAAO,MAAM,YAAY,IAAI;AAC/D,cAAM,EAAE,MAAM,cAAc,MAAM,OAAO,MAAM,QAAQ;AAAA,MACzD;AACA,iBAAW,YAAY,OAAO,MAAM,cAAc,CAAC,GAAG;AACpD,cAAM,UAAU,aAAa,IAAI,SAAS,KAAK,KAAK,EAAE,IAAI,IAAI,MAAM,IAAI,MAAM,GAAG;AACjF,YAAI,SAAS,MAAM,KAAM,SAAQ,KAAK,SAAS;AAC/C,YAAI,SAAS,UAAU,QAAQ,KAAM,SAAQ,OAAO,SAAS,SAAS;AACtE,YAAI,SAAS,UAAU,aAAa,KAAM,SAAQ,QAAQ,SAAS,SAAS;AAC5E,qBAAa,IAAI,SAAS,OAAO,OAAO;AAAA,MAC1C;AACA,UAAI,OAAO,iBAAiB,MAAM;AAChC,iBAAS,OAAO;AAChB,YAAI,CAAC,cAAc;AACjB,yBAAe;AACf,qBAAW,CAAC,EAAE,IAAI,KAAK,CAAC,GAAG,aAAa,QAAQ,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,IAAI,CAAC,GAAG;AAC5E,kBAAM;AAAA,cACJ,MAAM;AAAA,cACN,IAAI,KAAK;AAAA,cACT,MAAM,KAAK;AAAA,cACX,OAAO,KAAK,SAAS,KAAK,CAAC,IAAK,KAAK,MAAM,KAAK,IAAI;AAAA,YACtD;AAAA,UACF;AACA,uBAAa,MAAM;AAAA,QACrB;AAAA,MACF;AAAA,IACF;AACA,QAAI,MAAM,SAAS,MAAM;AACvB,YAAM,aAAa,MAAM,MAAM,uBAAuB,iBAAiB;AACvE,cAAQ;AAAA;AAAA;AAAA,QAGN,aAAa,KAAK,IAAI,GAAG,MAAM,MAAM,gBAAgB,UAAU;AAAA,QAC/D,cAAc,MAAM,MAAM;AAAA,MAC5B;AACA,UAAI,aAAa,EAAG,OAAM,uBAAuB;AAAA,IAEnD;AAAA,EACF;AAEA,MAAI,WAAW,MAAM;AACnB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,MAAI,UAAU,KAAM,OAAM,EAAE,MAAM,SAAS,MAAM;AACjD,QAAM,EAAE,MAAM,QAAQ,QAAQ,gBAAgB,MAAM,EAAE;AACxD;AAEA,SAAS,gBAAgB,QAA4B;AACnD,UAAQ,QAAQ;AAAA,IACd,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT;AAOE,YAAM,IAAI;AAAA,QACR,qCAAqC,KAAK,UAAU,MAAM,CAAC;AAAA,MAC7D;AAAA,EACJ;AACF;;;ADtRA,IAAM,sBAAsB;AAUrB,IAAM,wBAAN,MAAmD;AAAA,EAC/C;AAAA,EACA;AAAA,EAET,YAAY,MAAoC;AAC9C,QAAI,CAAC,MAAM,QAAQ,KAAK,SAAS,KAAK,KAAK,UAAU,WAAW,GAAG;AACjE,YAAM,IAAI;AAAA,QACR;AAAA,MAEF;AAAA,IACF;AACA,UAAM,UAA6B,EAAE,WAAW,CAAC,GAAG,KAAK,SAAS,EAAE;AACpE,QAAI,KAAK,mBAAmB,OAAW,SAAQ,iBAAiB,KAAK;AACrE,QAAI,KAAK,mBAAmB,OAAW,SAAQ,iBAAiB,KAAK;AACrE,QAAI,KAAK,sBAAsB,OAAW,SAAQ,oBAAoB,KAAK;AAC3E,SAAK,WAAW;AAEhB,UAAM,SAAS,KAAK,UAAU,QAAQ,IAAI,oBAAoB;AAC9D,QAAI,WAAW,UAAa,WAAW,IAAI;AACzC,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AACA,SAAK,UAAU,IAAIE,QAAO,EAAE,QAAQ,SAAS,KAAK,WAAW,oBAAoB,CAAC;AAAA,EACpF;AAAA,EAEA,OAAO,KAAmB,MAA4D;AAGpF,UAAM,SAAS,mBAAmB,KAAK,KAAK,QAAQ;AACpD,WAAO,0BAA0B,KAAK,WAAW,QAAQ,MAAM,MAAM,CAAC;AAAA,EACxE;AAAA,EAEA,OAAO,WACL,QACA,QAC6D;AAC7D,UAAM,SAAS,MAAM,KAAK,QAAQ,KAAK,YAAY;AAAA,MACjD;AAAA,MACA,WAAW,SAAY,EAAE,OAAO,IAAI;AAAA,IACtC;AACA,qBAAiB,SAAS,OAAQ,OAAM;AAAA,EAC1C;AACF;;;AE9BO,IAAM,sBAAsB,CAAC,aAAa,UAAU,YAAY;","names":["toTool","OpenAI","toTool","toUserContentPart","OpenAI"]}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@alma-harness/providers",
+  "version": "0.1.0",
+  "description": "ModelClient adapters for Anthropic and OpenAI over Alma's neutral message format.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/FabioFernandesCarneiro/alma.git",
+    "directory": "packages/providers"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.117.1",
+    "openai": "^7.5.0"
+  },
+  "peerDependencies": {
+    "@alma-harness/core": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.1.0",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "build": "tsup"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}