openpond-sdk 0.12.23 → 0.12.25

package/PRODUCT_INTEGRATION.md

@@ -0,0 +1,134 @@
+# Use OpenPond in your product
+
+The APIs below target the **0.12.25 source candidate**, which is not published
+yet. Registry version 0.12.24 does not include configured Dataset/named-model
+setup. Use the built candidate package until the coordinated release.
+
+
+Configure one application-owned server client. Bind aliases to exact callable
+Model IDs from your serving destination:
+
+```ts
+import { createOpenPondClient } from "openpond-sdk";
+
+export const openpond = createOpenPondClient({
+  apiKey: process.env.OPENPOND_API_KEY!,
+  teamId: process.env.OPENPOND_TEAM_ID!,
+  datasetId: process.env.OPENPOND_DATASET_ID!,
+  serving: {
+    baseUrl: process.env.OPENPOND_SERVING_BASE_URL!,
+    apiKey: process.env.OPENPOND_SERVING_API_KEY!,
+  },
+  models: { support: process.env.OPENPOND_MODEL_ID! },
+});
+
+const answer = await openpond.models.support.generate({ prompt: "How do I rotate a token?" });
+console.log(answer.text, answer.requestId, answer.usage);
+```
+
+`serving.baseUrl` is the personalized OpenAI-compatible Chat Completions base URL,
+including its `/v1` path. It is configured explicitly: no catalogue default or
+substitute Model is selected. Omit `serving.apiKey` only when this destination
+accepts the main API key. Naming a Model never activates serving, approves a
+candidate, starts training, or automatically captures inference as a task.
+Decision scorers use their separate typed scoring APIs.
+
+`generate` accepts either `prompt` or text `messages`, plus optional `temperature`,
+`maxTokens` and `signal`. Results include `text`, `requestId`, requested `modelId`,
+server-reported `resolvedModelId`, `finishReason`, nullable `usage`, and nullable
+`systemFingerprint`, plus retained server `evidence` when supplied. Evidence
+presence is not client-side verification. Core handles are text APIs; tools need
+the supported integration and explicit capabilities. The current personalized API
+rejects multimodal and structured-output modes. Aliases are typed TypeScript
+properties; multiple clients remain independent.
+
+```ts
+for await (const event of openpond.models.support.stream({ prompt: "Explain token rotation" })) {
+  if (event.type === "text") process.stdout.write(event.text);
+  else console.log(event.result.usage);
+}
+```
+
+Breaking the iteration cancels the response. An interrupted stream raises
+`ProductModelError` and never emits a successful `finish`. It may already have
+incurred usage; inference is never automatically replayed. `serving.timeoutMs`
+defaults to 60 seconds and accepts at most 300 seconds. Supply a caller abort
+signal to cancel an individual request. Text requests are bounded to 1 MiB and
+results to 8 MiB; individual stream frames to 1 MiB.
+
+Await task delivery separately with `openpond.addTask(...)`. If inference succeeds
+and optional task delivery fails, preserve both outcomes rather than discarding
+the delivery error or pretending the answer failed. See [task ingestion](TASK_INGESTION.md).
+
+## Python sync and async
+
+```python
+from ponder_sdk import AsyncClient
+
+async with AsyncClient(
+    base_url=api_origin, api_key=api_key, team_id=team_id,
+    dataset_id=dataset_id,
+    serving_base_url=serving_base_url, serving_api_key=serving_api_key,
+    model_aliases={"support": model_id},
+) as openpond:
+    answer = await openpond.models.support.generate(prompt="How do I rotate a token?")
+    print(answer.text, answer.request_id, answer.usage)
+    await openpond.add_task({"id": event_id, "name": "Token rotation", "input": {"question": question}})
+    async for event in openpond.models.support.stream(prompt="Explain the steps"):
+        if event.type == "text":
+            print(event.text, end="")
+```
+
+`Client` has the same configuration and synchronous calls/iteration. Named aliases
+augment existing Model administration methods; choose aliases that don't collide
+with those methods. Bracket access (`openpond.models["support"]`) is also available.
+Inference shares the existing client's HTTP pool and timeout. Close partially
+consumed iterators (or use `contextlib.closing`/`aclosing`) to release streams
+promptly. Native async cancellation propagates. No SDK queues or flush calls exist.
+
+## Optional Vercel AI SDK 7 integration
+
+Install `ai@^7.0.165` and `@ai-sdk/openai-compatible@^3.0.87` alongside OpenPond.
+Only the `openpond-sdk/ai-sdk` entry point imports the optional provider; task
+submission has no Vercel dependency. This adapter targets LanguageModelV4 and is
+not an upgrade of an application's existing AI SDK 4/5/6 installation.
+
+```ts
+import { generateText, streamText } from "ai";
+import { toAIModel } from "openpond-sdk/ai-sdk";
+import { openpond } from "./openpond.server.js";
+
+const model = toAIModel(openpond.models.support);
+const answer = await generateText({ model, prompt: "Explain token rotation", maxRetries: 0 });
+
+// Inside an authenticated product backend route:
+export async function POST(request: Request) {
+  // Authenticate the product user and validate/limit this payload first.
+  const { prompt } = await request.json();
+  const result = streamText({ model, prompt, abortSignal: request.signal, maxRetries: 0 });
+  return result.toUIMessageStreamResponse();
+}
+```
+
+Use the AI SDK 7 React `useChat`/transport recipe against your own authenticated
+backend. Never place the OpenPond client or secrets in browser code. AI SDK's UI
+stream response is different from raw OpenAI SSE; use
+`toUIMessageStreamResponse()` rather than forwarding raw SSE into `useChat`.
+
+The official compatible provider handles content/usage conversion, tool deltas and
+stream cancellation. OpenPond gates features against the selected binding:
+
+```ts
+models: {
+  support: {
+    id: process.env.OPENPOND_MODEL_ID!,
+    capabilities: { streaming: true, tools: true },
+  },
+}
+```
+
+Only enable tools after checking that exact deployment.
+Defaults are streaming enabled and tools disabled. Structured-output and multimodal
+inputs are rejected. Failed provider calls are surfaced as non-retryable SDK
+errors to prevent implicit replay of billed requests. Explicit `maxRetries: 0`
+also makes that intent visible in application code.

package/README.md

@@ -392,4 +392,15 @@ not implicitly share a spending cap.
 
 ## Add production tasks
 
-Use the flat `client.addTask(datasetId, task)` operation, or bind one destination with `createTaskAdder` and call `addTask(task)`. See [task ingestion](TASK_INGESTION.md) for TypeScript/Python examples, receipt semantics and duplicate-safe retries. Task uploads do not enable training.
+The configured API targets unpublished source candidate **0.12.25**; registry 0.12.24 does not provide it. Configure `datasetId` once and await `client.addTask({ id: sourceEventId, name, input })`. Use `client.dataset(otherDatasetId).addTask(task)` for another destination. See [task ingestion](TASK_INGESTION.md) for TypeScript/Python examples, receipt semantics and duplicate-safe retries. Task uploads do not enable training.
+
+Dataset workspace HTTP failures throw `DatasetWorkspaceRequestError` from
+`openpond-sdk/dataset-workspaces`, with `status`, an allowlisted `code`,
+`retryable`, and `outcomeUnknown`. Messages contain fixed recovery guidance;
+raw server diagnostics are discarded. `retryable` does not trigger an automatic
+retry. When `outcomeUnknown` is true, retain the original operation ID and request
+bytes, recover its receipt with `operationResult`, or retry the identical request.
+
+## Add OpenPond to a product
+
+Configure named personalized Model handles with `models` and an explicit `serving` destination, then call `client.models.support.generate({ prompt })` or iterate `stream({ prompt })`. See [product integration](PRODUCT_INTEGRATION.md) for TypeScript, Python, React/backend and optional Vercel AI SDK 7 examples. Inference never activates serving or automatically captures tasks.

package/TASK_INGESTION.md

@@ -1,135 +1,137 @@
 # Add tasks to a Dataset
 
-Task submission uses an authenticated OpenPond API, separate from OpenTelemetry.
-A successful receipt means a structured task was durably saved and is available
-through the ordinary Dataset Tasks reader. It does not start training, publish
-a release, create a Model or enable a collection schedule.
+The APIs below target the **0.12.25 source candidate**, which is not published
+yet. Registry version 0.12.24 does not include configured Dataset/named-model
+setup. Use the built candidate package until the coordinated release.
 
-Create or choose an editable Dataset in Console and copy its ID. Configure the
-server-side SDK with the workspace that owns it:
+
+Configure a client once in your product's server module. Submit one structured
+source event with `await addTask(task)`:
 
 ```ts
 import { createOpenPondClient } from "openpond-sdk";
 
-const client = createOpenPondClient({
+export const openpond = createOpenPondClient({
   apiKey: process.env.OPENPOND_API_KEY!,
   teamId: process.env.OPENPOND_TEAM_ID!,
+  datasetId: process.env.OPENPOND_DATASET_ID!,
 });
 
-const receipt = await client.addTask(process.env.OPENPOND_DATASET_ID!, {
+const receipt = await openpond.addTask({
+  id: sourceEventId,
   name: "Handle an expired API token",
   input: { request: "Fetch the report", observedError: "Token expired" },
-  source: { kind: "production_agent", eventId: "run-123" },
-}, { idempotencyKey: "run-123" });
-
+  source: { kind: "production_agent", eventId: sourceEventId },
+});
 console.log(receipt.taskId, receipt.receivedAt);
 ```
 
-Use a configured `baseUrl` when targeting a different OpenPond API origin.
-Never expose the API key in browser code or logged task content.
-
-## Bind the destination once
+Use `baseUrl` for a different OpenPond API origin. Each configured client keeps
+its own credentials and destination; no mutable global account is used. For an
+explicit alternate Dataset:
 
 ```ts
-import { createTaskAdder } from "openpond-sdk";
-
-const addTask = createTaskAdder({
-  apiKey: process.env.OPENPOND_API_KEY!,
-  teamId: process.env.OPENPOND_TEAM_ID!,
-  datasetId: process.env.OPENPOND_DATASET_ID!,
-  baseUrl: "https://api.openpond.ai",
-});
-
-await addTask({
+await openpond.dataset(otherDatasetId).addTask({
+  id: sourceEventId,
   name: "Explain a failed agent run",
   input: { request: "Summarize the report", outcome: "incomplete" },
-}, { idempotencyKey: "agent-run-456" });
+});
 ```
 
-The Dataset ID is still included in every request. The helper binds it locally;
-it never uses a global account, last-selected Dataset or implicit Fix-it Model.
+`addTask(datasetId, task)` and the `createTaskAdder` helper remain available.
 
-## Input and receipt
+## Delivery, identity and retries
 
-Every task has a readable `name` and structured `input`. Optional fields are
-`expectedOutput`, `split`, `tags` and `source` (`kind`, `eventId`, `label`,
-`occurredAt`). The default split is `validation`. A `train` split alone does
-not authorize training. Keep a missing correct answer absent rather than
-replacing it with an error message.
+A successful receipt confirms durable storage of the task and its processing
+obligation. It does not wait for indexing, grading or training. Dataset projection
+may lag acknowledgement. Await suspends this async function while the JavaScript
+event loop continues handling other work. There is no SDK background queue,
+flush command or permanent streaming connection.
 
-The complete request is bounded to 128 KiB. The receipt includes workspace,
-Dataset, task and operation identities, server `receivedAt`, saved revision,
-`state: "saved"` and `trainingUseAuthorized: false`. Source occurrence time is
-different from server upload time.
+`id` identifies the source event within the workspace and Dataset. It is separate
+from the server's canonical `receipt.taskId`. Repeating the same source ID and
+content returns the original receipt; changed content conflicts instead of
+silently overwriting. New credentials still need current authorization for that
+exact Dataset. A successful upload grants no training permission.
 
-## Delivery and retries
-
-Retain an explicit stable idempotency key for each source event. Repeating the
-same key and task in the same authorized destination returns the original
-receipt without inserting a duplicate. Reusing a key with different content is
-a conflict. Separate keys add separate tasks, including simultaneous writers.
-
-The SDK makes one request; it does not silently replay arbitrary mutations.
-When a response is lost, `DatasetTaskIngestionError.operationId` retains the
-operation identity and `outcomeUnknown` indicates that persistence could not be
-confirmed. Retry the original task with that same key. Do not generate a new
-key merely because the response was interrupted. A supplied abort signal is
-forwarded to the request; an interrupted response can still have been saved.
+The SDK sends once. It never automatically replays a mutation. Preserve your
+source ID and original content across uncertain outcomes:
 
 ```ts
 import { DatasetTaskIngestionError } from "openpond-sdk";
 
+const task = { id: sourceEventId, name: "Expired token", input: { error: "expired" } };
 try {
-  await addTask(task, { idempotencyKey: sourceEventId });
+  await openpond.addTask(task, { signal: request.signal, timeoutMs: 10_000 });
 } catch (error) {
   if (error instanceof DatasetTaskIngestionError && error.outcomeUnknown) {
-    // Retain task + error.operationId privately for a later exact retry.
+    // Retain task and error.sourceId privately for a later exact retry.
   }
   throw error;
 }
 ```
 
-The underlying route is `POST /v1/dataset-workspaces/{datasetId}/tasks`, with
-`Authorization: Bearer …`, `X-OpenPond-Team-Id` and JSON:
-
-```json
-{
-  "schemaVersion": "openpond.datasetTaskAppend.v1",
-  "operationId": "stable-source-event",
-  "task": {
-    "name": "Handle an expired API token",
-    "input": { "observedError": "Token expired" }
-  }
-}
-```
-
-The server owns authorization, atomic append and revision history. Appending
-does not rewrite fixed Experiment Dataset versions or previously published
-releases. Full authoring still uses the revisioned Dataset workspace API.
+When `id` is omitted the SDK generates one before dispatch. On uncertain delivery,
+`DatasetTaskIngestionError.sourceId` (also `operationId`) retains it. Supply that
+ID in a later retry. Prefer an explicit ID when cancellation or process exit could
+prevent handling the error. An event never transmitted successfully cannot be
+promised durable. `idempotencyKey` is accepted for existing callers; supplying a
+conflicting `task.id` is rejected before dispatch.
+
+Every task has `name` and structured `input`. Optional fields: `expectedOutput`,
+`split`, `tags`, and `source` (`kind`, `eventId`, `label`, `occurredAt`). Default
+split: `validation`; `train` alone grants no learning authority. Requests are
+bounded to 128 KiB. The receipt retains workspace, Dataset, canonical task and
+source identities, first-save `receivedAt`, revision, `state: "saved"` and
+`trainingUseAuthorized: false`. Source occurrence time differs from upload time.
+Existing immutable releases and Experiment inputs retain their own identities.
 
 ## Python
 
-The maintained `ponder-sdk` package exposes the same operation on `Client`
-and `AsyncClient`:
+`ponder-sdk` uses the same configured destination and source ID with its native
+owned connection pool:
 
 ```python
 from ponder_sdk import Client
 
-with Client(base_url=api_origin, api_key=api_key, team_id=team_id) as client:
-    receipt = client.add_task(
-        dataset_id,
-        {"name": "Handle an expired API token", "input": {"error": "Token expired"}},
-        idempotency_key=source_event_id,
-    )
+with Client(base_url=api_origin, api_key=api_key, team_id=team_id,
+            dataset_id=dataset_id) as openpond:
+    receipt = openpond.add_task({
+        "id": source_event_id,
+        "name": "Expired token",
+        "input": {"error": "Token expired"},
+    })
+    # Alternate destination; uses the same pool:
+    # openpond.dataset(other_dataset_id).add_task(task)
 ```
 
-Use `async with AsyncClient(...)` and `await client.add_task(...)` for async
-applications. Both use the existing client connection pool and typed wire
-validation. Retain the caller's key/task across an unknown mutation outcome.
+Sync calls block their calling thread. Async applications use
+`async with AsyncClient(...)` and `await openpond.add_task(task)`. Both validate the
+maintained wire schemas and never replay writes automatically. A `PonderError`
+retains `operation_id` and `outcome_unknown`; cancellation propagates, so retain
+your own source ID before awaiting. Closing the HTTP pool is resource cleanup,
+not delivery flushing.
+
+## HTTP and React
+
+The HTTP operation remains `POST /v1/dataset-workspaces/{datasetId}/tasks` with
+Bearer auth and `X-OpenPond-Team-Id`. The public `task.id` maps to wire
+`operationId`; it is excluded from `task` content:
+
+```json
+{
+  "schemaVersion": "openpond.datasetTaskAppend.v1",
+  "operationId": "stable-source-event",
+  "task": { "name": "Expired token", "input": { "error": "expired" } }
+}
+```
 
-## OpenTelemetry
+React calls your authenticated product backend. The backend selects an authorized
+Dataset and awaits the configured client. Keep OpenPond secrets and destination
+authority server-side; do not accept an arbitrary browser-supplied Dataset ID.
+For named model calls and the optional Vercel integration see
+[product integration](PRODUCT_INTEGRATION.md).
 
-OpenTelemetry is an optional source adapter, not this HTTP request format.
-Its span exporter can project explicitly selected spans into structured tasks
-using the same destination and receipts. It does not make this endpoint an
-OTLP receiver, automatically capture arbitrary logs, or authorize training.
+OpenTelemetry is a separate optional source adapter, not this request format.
+Project explicitly selected spans into structured tasks. This endpoint is not an
+OTLP receiver and does not capture arbitrary logs or authorize training.

package/TRAINING_PROTOCOL.md

@@ -50,8 +50,8 @@ GET  /v1/training/jobs?modelProjectId=&cursor=&limit=
 GET  /v1/training/jobs/{jobId}
 POST /v1/training/jobs/{jobId}/cancel
 POST /v1/training/jobs/{jobId}/stop-after-group
-GET  /v1/training/jobs/{jobId}/events
-GET  /v1/training/jobs/{jobId}/logs
+GET  /v1/training/jobs/{jobId}/events?after=0&limit=50
+GET  /v1/training/jobs/{jobId}/logs?after=0&limit=50
 GET  /v1/training/jobs/{jobId}/outputs
 
 PUT  /v1/model-projects/{portableProjectId}
@@ -328,3 +328,7 @@ It performs no authentication, network upload, tool execution, training, or mode
 activation. Callers must verify authentic durable hosted receipts before
 acknowledging delivery. Import the portable entry in browser code; the Node queue
 is a separate runtime capability.
+
+### Retained evidence pagination
+
+Events and logs return at most 100 records per database-selected page (default 50), plus `nextOffset` or `null`. Use `training.eventsPage(jobId, { after, limit })` and `training.logsPage(...)` to obtain `{ items, nextOffset }`. The SDK validates the returned job, sequence window, count and continuation before exposing records. Offsets address the current ordered snapshot; lifecycle snapshots can change while a run is live. They are not an immutable append-only cursor. Existing `events()`/`logs()` convenience reads follow pages with an aggregate response-byte budget and a 100,000-record ceiling. MCP requests exactly one page.

package/TRAINING_WORKFLOWS.md

@@ -653,3 +653,19 @@ evaluation remains an independent candidate check. A nightly schedule uses the
 authored time and timezone, waits for approved unused examples, and respects the
 saved task threshold and spend limits. It does not itself enable conversation
 collection, automatic data approval, or automatic serving.
+
+
+Selective neuron continuation uses an exact compatible saved neuron version.
+`neuronTrainingFormFromModelVersion` retains that version and its cumulative
+patch, copies the parent's selection configuration, clears the target choice,
+and requires reviewed new target data. `background=[]` retains the original
+selection as inherited evidence; it does not report selection on the new data.
+The explicit mode is `frozen_parent_fresh_residual_adam_v1`: the parent stays
+frozen, fresh zero column parameters use the original dense base as their
+anchors, and a fresh Adam optimizer learns a residual. No optimizer or RNG
+checkpoint is resumed. Optional preservation compares against the starting
+base plus parent patch. The worker verifies the exact parent bytes before
+optimizer creation and exports a cumulative patch with parent, initial and
+final state hashes. A runtime must explicitly advertise this mode before
+admission; source packaging alone does not establish native qualification or
+old/new held-out retention.

package/dist/advanced-refiner-evaluations.js

@@ -12,12 +12,12 @@ import {
   sealAdvancedRefinerEvaluationPin,
   sealAdvancedRefinerReviewReceipt,
   verifyAdvancedRefinerEvaluationPin
-} from "./chunk-6EZAGTZG.js";
-import "./chunk-3B5KSH3V.js";
-import "./chunk-H3367ISL.js";
+} from "./chunk-RN5MK7NH.js";
 import "./chunk-QNOCM5JX.js";
+import "./chunk-3B5KSH3V.js";
 import "./chunk-626JLH4D.js";
 import "./chunk-O6FKHAWN.js";
+import "./chunk-H3367ISL.js";
 import "./chunk-GS5HEE4M.js";
 import "./chunk-ZRTNR4U7.js";
 import "./chunk-JMFYNIYZ.js";

package/dist/ai-sdk.js

@@ -0,0 +1,224 @@
+import {
+  ProductModelError,
+  productModelEndpoint
+} from "./chunk-BRP3EBCR.js";
+import "./chunk-B3ZHJ2KK.js";
+import "./chunk-YLJ4XMA6.js";
+
+// src/ai-sdk.ts
+import {
+  createOpenAICompatible
+} from "@ai-sdk/openai-compatible";
+import { z } from "zod";
+
+// src/product-model-response.ts
+function boundProductModelResponse(response) {
+  if (!response.body) return response;
+  const streaming = response.headers.get("content-type")?.includes("text/event-stream") ?? false;
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let total = 0, pending = "", terminal = false;
+  let identity;
+  const fail = () => new ProductModelError(
+    streaming ? "model_stream_interrupted" : "model_response_invalid",
+    response.status,
+    true,
+    response.headers.get("x-openpond-request-id") ?? response.headers.get("x-request-id") ?? void 0
+  );
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          if (streaming && !terminal) throw fail();
+          controller.close();
+          reader.releaseLock();
+          return;
+        }
+        total += value.byteLength;
+        if (total > 8 * 1024 * 1024) throw fail();
+        if (streaming) {
+          pending = (pending + decoder.decode(value, { stream: true })).replace(/\r\n/g, "\n");
+          let boundary;
+          while ((boundary = pending.indexOf("\n\n")) >= 0) {
+            const frame = pending.slice(0, boundary);
+            pending = pending.slice(boundary + 2);
+            if (new TextEncoder().encode(frame).length > 1024 * 1024) throw fail();
+            const data = frame.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+            if (data === "[DONE]") terminal = true;
+            else if (data) {
+              const chunk = JSON.parse(data);
+              if (typeof chunk.id === "string" && typeof chunk.model === "string") {
+                if (identity && (chunk.id !== identity.id || chunk.model !== identity.model))
+                  throw fail();
+                identity = { id: chunk.id, model: chunk.model };
+              }
+            }
+          }
+          if (new TextEncoder().encode(pending).length > 1024 * 1024) throw fail();
+        }
+        controller.enqueue(value);
+      } catch {
+        await reader.cancel().catch(() => {
+        });
+        controller.error(fail());
+      }
+    },
+    async cancel(reason) {
+      await reader.cancel(reason);
+    }
+  });
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+
+// src/ai-sdk.ts
+var Evidence = z.object({ openpond: z.record(z.string(), z.json()) }).passthrough();
+function metadata(raw) {
+  const value = Evidence.safeParse(raw);
+  return value.success ? { openpond: value.data.openpond } : void 0;
+}
+function toAIModel(model) {
+  const connection = model.providerConnection();
+  const provider = createOpenAICompatible({
+    name: "openpond",
+    baseURL: productModelEndpoint(connection.baseUrl),
+    apiKey: connection.apiKey,
+    // The personalized gateway always supplies terminal usage and rejects
+    // OpenAI's optional stream_options field.
+    includeUsage: false,
+    headers: connection.teamId ? { "X-OpenPond-Team-Id": connection.teamId } : void 0,
+    transformRequestBody: (raw) => {
+      const body = JSON.parse(JSON.stringify(raw));
+      if (body.model !== model.id)
+        throw new ProductModelError("model_override_forbidden", 0, false);
+      const allowed = /* @__PURE__ */ new Set([
+        "model",
+        "messages",
+        "stream",
+        "max_tokens",
+        "temperature",
+        "top_p",
+        "seed",
+        "stop",
+        "tools",
+        "tool_choice"
+      ]);
+      if (Object.keys(body).some((key) => !allowed.has(key)))
+        throw new ProductModelError("parameter_unsupported", 0, false);
+      return body;
+    },
+    metadataExtractor: {
+      async extractMetadata({ parsedBody }) {
+        return metadata(parsedBody);
+      },
+      createStreamExtractor() {
+        let evidence;
+        return {
+          processChunk(chunk) {
+            evidence = metadata(chunk) ?? evidence;
+          },
+          buildMetadata() {
+            return evidence;
+          }
+        };
+      }
+    },
+    supportsStructuredOutputs: model.capabilities.structuredOutput,
+    fetch: async (url, init) => {
+      const timeout = AbortSignal.timeout(connection.timeoutMs ?? 6e4);
+      const headers = new Headers(init?.headers);
+      headers.set("Authorization", `Bearer ${connection.apiKey}`);
+      if (connection.teamId) headers.set("X-OpenPond-Team-Id", connection.teamId);
+      return boundProductModelResponse(
+        await (connection.fetch ?? fetch)(url, {
+          ...init,
+          redirect: "error",
+          headers,
+          signal: init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout
+        })
+      );
+    }
+  }).chatModel(model.id);
+  const check = (options) => {
+    const rawOptions = options.providerOptions?.openpond;
+    if (rawOptions && ["stream", "stream_options"].some((key) => key in rawOptions))
+      throw new ProductModelError("transport_override_forbidden", 0, false);
+    if (options.tools?.length && !model.capabilities.tools)
+      throw new ProductModelError("tools_unsupported", 0, false);
+    if (options.responseFormat?.type === "json")
+      throw new ProductModelError("structured_output_unsupported", 0, false);
+    if (options.prompt.some(
+      (message) => message.role === "tool" && !model.capabilities.tools || message.role !== "system" && message.content.some(
+        (part) => part.type !== "text" && !(model.capabilities.tools && ["tool-call", "tool-result"].includes(part.type))
+      )
+    ))
+      throw new ProductModelError("input_capability_unsupported", 0, false);
+  };
+  const normalizeError = (error) => {
+    if (error instanceof ProductModelError) return error;
+    if (error && typeof error === "object" && "cause" in error && error.cause instanceof ProductModelError)
+      return error.cause;
+    const status = error && typeof error === "object" && "statusCode" in error && typeof error.statusCode === "number" ? error.statusCode : 0;
+    const unknown = status === 0 || status === 408 || status >= 500 || status >= 200 && status < 300;
+    return new ProductModelError(
+      status >= 400 ? "model_request_rejected" : "model_outcome_unknown",
+      status,
+      unknown
+    );
+  };
+  return {
+    specificationVersion: provider.specificationVersion,
+    provider: provider.provider,
+    modelId: provider.modelId,
+    supportedUrls: provider.supportedUrls,
+    async doGenerate(options) {
+      check(options);
+      try {
+        return await provider.doGenerate(options);
+      } catch (error) {
+        throw normalizeError(error);
+      }
+    },
+    async doStream(options) {
+      check(options);
+      if (!model.capabilities.streaming)
+        throw new ProductModelError("streaming_unsupported", 0, false);
+      try {
+        const result = await provider.doStream(options);
+        const reader = result.stream.getReader();
+        return {
+          ...result,
+          stream: new ReadableStream({
+            async pull(controller) {
+              try {
+                const { done, value } = await reader.read();
+                if (done) {
+                  controller.close();
+                  reader.releaseLock();
+                } else
+                  controller.enqueue(
+                    value.type === "error" ? { ...value, error: normalizeError(value.error) } : value
+                  );
+              } catch (error) {
+                controller.error(normalizeError(error));
+              }
+            },
+            async cancel(reason) {
+              await reader.cancel(reason);
+            }
+          })
+        };
+      } catch (error) {
+        throw normalizeError(error);
+      }
+    }
+  };
+}
+export {
+  toAIModel
+};
+//# sourceMappingURL=ai-sdk.js.map