openpond-sdk 0.12.25 → 0.12.27

package/dist/chunk-ON3KSXWR.js

@@ -0,0 +1,639 @@
+import {
+  readBoundedJsonResponse
+} from "./chunk-B3ZHJ2KK.js";
+import {
+  DEFAULT_MODEL_BASE_URL
+} from "./chunk-QYWPNNP3.js";
+
+// src/product-model-wire.ts
+import { z } from "zod";
+var ProductModelError = class extends Error {
+  constructor(code, status, outcomeUnknown, requestId, clientRequestId) {
+    super(`OpenPond model request failed (${code}).`);
+    this.code = code;
+    this.status = status;
+    this.outcomeUnknown = outcomeUnknown;
+    this.requestId = requestId;
+    this.clientRequestId = clientRequestId;
+    this.name = "ProductModelError";
+  }
+  code;
+  status;
+  outcomeUnknown;
+  requestId;
+  clientRequestId;
+};
+var ProductModelToolCallSchema = z.object({
+  id: z.string(),
+  type: z.literal("function").default("function"),
+  function: z.object({ name: z.string(), arguments: z.string() })
+}).passthrough();
+var ProductModelUsageSchema = z.object({
+  prompt_tokens: z.number().int().nonnegative(),
+  completion_tokens: z.number().int().nonnegative(),
+  total_tokens: z.number().int().nonnegative()
+});
+var ProductModelChunkSchema = z.object({
+  id: z.string(),
+  model: z.string(),
+  system_fingerprint: z.string().nullable().optional(),
+  openpond: z.record(z.string(), z.json()).optional(),
+  usage: ProductModelUsageSchema.nullable().optional(),
+  choices: z.array(
+    z.object({
+      index: z.number().int(),
+      finish_reason: z.string().nullable().optional(),
+      delta: z.object({
+        content: z.string().nullable().optional(),
+        tool_calls: z.unknown().optional()
+      }).passthrough().optional(),
+      message: z.object({
+        content: z.string().nullable(),
+        tool_calls: z.unknown().optional()
+      }).passthrough().optional()
+    })
+  ).max(1)
+}).passthrough();
+var ProductModelRequestStatusSchema = z.object({
+  schemaVersion: z.literal("openpond.modelRequestStatus.v1"),
+  requestId: z.string().regex(/^pinf_[A-Za-z0-9-]{8,191}$/),
+  clientRequestId: z.uuid().nullable(),
+  modelId: z.string(),
+  state: z.enum([
+    "pending",
+    "running",
+    "stopping",
+    "completed",
+    "failed",
+    "cancelled"
+  ]),
+  deadlineAt: z.iso.datetime(),
+  retryAt: z.iso.datetime().nullable(),
+  result: ProductModelChunkSchema.nullable(),
+  failureCode: z.string().nullable()
+}).strict();
+function canonicalResponseModelId(modelId) {
+  const name = modelId.startsWith("personalized:") ? modelId.slice("personalized:".length) : null;
+  return name && /^[a-z0-9][a-z0-9._:-]{2,127}$/.test(name) ? name : modelId;
+}
+function productModelEndpoint(value) {
+  const url = new URL(value);
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+    throw new Error("A clean serving base URL is required.");
+  return url.href.replace(/\/$/, "");
+}
+
+// src/product-model-transport.ts
+import { z as z2 } from "zod";
+
+// src/product-model-response.ts
+function boundProductModelResponse(response, context = {}) {
+  const headers = new Headers(response.headers);
+  if (context.clientRequestId) headers.set("x-openpond-client-request-id", context.clientRequestId);
+  if (!response.body) return new Response(null, { status: response.status, statusText: response.statusText, headers });
+  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,
+    context.requestId ?? response.headers.get("x-openpond-request-id") ?? response.headers.get("x-request-id") ?? void 0,
+    context.clientRequestId
+  );
+  let closed = false;
+  let cancellation;
+  const cancelReader = (reason) => cancellation ??= reader.cancel(reason).finally(() => reader.releaseLock());
+  let abort;
+  const cleanup = () => {
+    if (abort) context.signal?.removeEventListener("abort", abort);
+  };
+  const body = new ReadableStream({
+    start(controller) {
+      abort = () => {
+        if (closed) return;
+        closed = true;
+        cleanup();
+        void cancelReader().catch(() => {
+        });
+        controller.error(fail());
+      };
+      context.signal?.addEventListener("abort", abort, { once: true });
+      if (context.signal?.aborted) abort();
+    },
+    async pull(controller) {
+      if (closed) return;
+      try {
+        const { done, value } = await reader.read();
+        if (closed) return;
+        if (done) {
+          if (streaming && !terminal) throw fail();
+          closed = true;
+          cleanup();
+          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 {
+        if (closed) return;
+        closed = true;
+        cleanup();
+        await cancelReader().catch(() => {
+        });
+        controller.error(fail());
+      }
+    },
+    async cancel(reason) {
+      closed = true;
+      cleanup();
+      await cancelReader(reason);
+    }
+  });
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+
+// src/product-model-transport.ts
+var MAX_BODY_BYTES = 8 * 1024 * 1024;
+var RequestId = ProductModelRequestStatusSchema.shape.requestId;
+var unknown = (identity, status = 0) => new ProductModelError("model_outcome_unknown", status, true, identity.requestId, identity.clientRequestId);
+var ProductModelTransport = class {
+  constructor(modelId, connection) {
+    this.modelId = modelId;
+    this.connection = connection;
+    this.endpoint = `${productModelEndpoint(connection.baseUrl)}/chat/completions`;
+  }
+  modelId;
+  connection;
+  identities = /* @__PURE__ */ new WeakMap();
+  endpoint;
+  identity(response) {
+    return this.identities.get(response) ?? {};
+  }
+  budget(timeoutMs, signal) {
+    const timeout = AbortSignal.timeout(timeoutMs);
+    return { until: Date.now() + timeoutMs, signal: signal ? AbortSignal.any([signal, timeout]) : timeout };
+  }
+  headers(extra) {
+    const headers = new Headers(extra);
+    headers.delete("openpond-api-key");
+    headers.set("Authorization", `Bearer ${this.connection.apiKey}`);
+    headers.delete("X-OpenPond-Team-Id");
+    if (this.connection.teamId) headers.set("X-OpenPond-Team-Id", this.connection.teamId);
+    return headers;
+  }
+  async fetchResponse(url, init, budget, identity) {
+    if (budget.signal.aborted || Date.now() >= budget.until) throw unknown(identity);
+    let response;
+    try {
+      response = await (this.connection.fetch ?? fetch)(url, {
+        ...init,
+        redirect: "error",
+        signal: budget.signal
+      });
+    } catch {
+      throw unknown(identity);
+    }
+    const observedId = response.headers.get("x-openpond-request-id") ?? response.headers.get("x-request-id");
+    if (!identity.requestId && observedId && (init.method !== "GET" && response.status !== 202 || RequestId.safeParse(observedId).success)) identity.requestId = observedId;
+    if (!response.ok) {
+      await response.body?.cancel().catch(() => {
+      });
+      throw new ProductModelError(
+        init.method === "GET" ? "model_status_unavailable" : "model_request_rejected",
+        response.status,
+        response.status === 408 || response.status >= 500,
+        identity.requestId,
+        identity.clientRequestId
+      );
+    }
+    const bounded = boundProductModelResponse(response, { signal: budget.signal, ...identity });
+    this.identities.set(bounded, { ...identity });
+    return bounded;
+  }
+  async request(body, options) {
+    if (new TextEncoder().encode(body).length > 1024 * 1024)
+      throw new ProductModelError("payload_too_large", 0, false);
+    const headers = this.headers(options.headers);
+    const parsedId = z2.uuid().safeParse(options.clientRequestId ?? headers.get("X-OpenPond-Client-Request-Id") ?? crypto.randomUUID());
+    if (!parsedId.success) throw new ProductModelError("client_request_id_invalid", 0, false);
+    const identity = { clientRequestId: parsedId.data };
+    headers.set("X-OpenPond-Client-Request-Id", parsedId.data);
+    headers.delete("idempotency-key");
+    headers.delete("x-request-id");
+    headers.set("Content-Type", "application/json");
+    headers.set("Accept", options.stream ? "text/event-stream" : "application/json");
+    const budget = this.budget(this.connection.timeoutMs ?? 63e4, options.signal);
+    const response = await this.fetchResponse(this.endpoint, { method: "POST", headers, body }, budget, identity);
+    if (response.status !== 202) return response;
+    const completion = await this.observePending(response, identity, budget);
+    let terminal;
+    try {
+      terminal = terminalResponse(completion, options.stream);
+    } catch {
+      throw new ProductModelError("model_response_invalid", 200, true, identity.requestId, identity.clientRequestId);
+    }
+    const bounded = boundProductModelResponse(terminal, { signal: budget.signal, ...identity });
+    this.identities.set(bounded, { ...identity });
+    return bounded;
+  }
+  async parseStatus(response, expected, deadlineAt) {
+    let status;
+    try {
+      status = ProductModelRequestStatusSchema.parse(await readBoundedJsonResponse(response, MAX_BODY_BYTES, "Model status"));
+    } catch {
+      throw new ProductModelError("model_response_invalid", response.status, true, expected.requestId, expected.clientRequestId);
+    }
+    if (status.modelId !== canonicalResponseModelId(this.modelId) || expected.requestId !== void 0 && status.requestId !== expected.requestId || expected.clientRequestId !== void 0 && status.clientRequestId !== expected.clientRequestId || deadlineAt !== void 0 && status.deadlineAt !== deadlineAt)
+      throw new ProductModelError("model_recovery_identity_changed", 409, true, expected.requestId, expected.clientRequestId);
+    if (status.result && (status.state !== "completed" || status.failureCode !== null || status.result.id !== status.requestId || status.result.model !== status.modelId || status.result.choices.length !== 1 || status.result.choices[0]?.index !== 0 || !status.result.choices[0]?.message || !status.result.choices[0]?.finish_reason))
+      throw new ProductModelError("model_response_invalid", response.status, true, status.requestId, expected.clientRequestId);
+    return status;
+  }
+  async readStatus(suffix, expected, budget, deadlineAt) {
+    const headers = this.headers();
+    headers.set("Accept", "application/json");
+    const response = await this.fetchResponse(`${this.endpoint}${suffix}`, { method: "GET", headers }, budget, expected);
+    return this.parseStatus(response, expected, deadlineAt);
+  }
+  async inspectRequest(requestId) {
+    const id = RequestId.parse(requestId);
+    return this.readStatus(`/${encodeURIComponent(id)}`, { requestId: id }, this.budget(3e4));
+  }
+  async recover(clientRequestId) {
+    const id = z2.uuid().parse(clientRequestId);
+    return this.readStatus(`?clientRequestId=${encodeURIComponent(id)}`, { clientRequestId: id }, this.budget(3e4));
+  }
+  async observePending(response, identity, budget) {
+    let status = await this.parseStatus(response, identity);
+    identity.requestId = status.requestId;
+    const deadlineAt = status.deadlineAt;
+    const remaining = Math.min(budget.until, Date.parse(deadlineAt) + 3e4) - Date.now();
+    if (remaining <= 0) throw unknown(identity, 202);
+    const observation = this.budget(remaining, budget.signal);
+    budget.until = observation.until;
+    budget.signal = observation.signal;
+    for (; ; ) {
+      if (observation.signal.aborted) throw unknown(identity, 202);
+      if (status.state === "completed" && status.result) return status.result;
+      if (status.state === "completed" || status.state === "failed" || status.state === "cancelled")
+        throw new ProductModelError(
+          status.state === "completed" ? "model_result_not_retained" : "model_request_failed",
+          200,
+          false,
+          identity.requestId,
+          identity.clientRequestId
+        );
+      const delay = Math.min(observation.until - Date.now(), Math.max(
+        500,
+        Math.min(15e3, status.retryAt ? Date.parse(status.retryAt) - Date.now() : 2e3)
+      ));
+      await waitForObservation(delay, observation.signal, identity);
+      try {
+        status = await this.readStatus(
+          `/${encodeURIComponent(identity.requestId)}`,
+          identity,
+          this.budget(Math.max(1, Math.min(3e4, observation.until - Date.now())), observation.signal),
+          deadlineAt
+        );
+      } catch (error) {
+        if (error instanceof ProductModelError && ["model_recovery_identity_changed", "model_response_invalid"].includes(error.code)) throw error;
+        throw unknown(identity, 202);
+      }
+    }
+  }
+  async cancelRequest(requestId) {
+    const id = RequestId.parse(requestId);
+    try {
+      const response = await this.fetchResponse(
+        `${this.endpoint}/${encodeURIComponent(id)}/cancel`,
+        { method: "POST", headers: this.headers() },
+        this.budget(3e4),
+        { requestId: id }
+      );
+      await response.body?.cancel();
+    } catch {
+      throw new ProductModelError("model_cancel_pending", 0, true, id);
+    }
+  }
+};
+async function waitForObservation(delay, signal, identity) {
+  if (signal.aborted || delay <= 0) throw unknown(identity, 202);
+  await new Promise((resolve, reject) => {
+    const abort = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", abort);
+      reject(unknown(identity, 202));
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", abort);
+      resolve();
+    }, delay);
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) abort();
+  });
+}
+var ToolCalls = z2.array(ProductModelToolCallSchema);
+function terminalResponse(completion, stream) {
+  const headers = { "x-openpond-request-id": completion.id, "cache-control": "private, no-store" };
+  if (!stream) return Response.json(completion, { headers });
+  const choice = completion.choices[0], message = choice.message;
+  const identity = {
+    id: completion.id,
+    model: completion.model,
+    created: completion.created,
+    system_fingerprint: completion.system_fingerprint
+  };
+  const frames = [];
+  const emit = (delta) => frames.push(`data: ${JSON.stringify({
+    ...identity,
+    choices: [{ index: 0, delta, finish_reason: null }]
+  })}
+
+`);
+  emit({ role: "assistant" });
+  if (message.content) for (let offset = 0; offset < message.content.length; offset += 16384)
+    emit({ content: message.content.slice(offset, offset + 16384) });
+  if (message.tool_calls !== void 0 && message.tool_calls !== null) {
+    const tools = ToolCalls.parse(message.tool_calls);
+    for (const [index, tool] of tools.entries()) {
+      emit({ tool_calls: [{ ...tool, index, type: "function", function: { name: tool.function.name, arguments: "" } }] });
+      for (let offset = 0; offset < tool.function.arguments.length; offset += 16384)
+        emit({ tool_calls: [{ index, function: { arguments: tool.function.arguments.slice(offset, offset + 16384) } }] });
+    }
+  }
+  frames.push(`data: ${JSON.stringify({
+    ...identity,
+    openpond: completion.openpond,
+    usage: completion.usage,
+    choices: [{ index: 0, delta: {}, finish_reason: choice.finish_reason }]
+  })}
+
+`, "data: [DONE]\n\n");
+  return new Response(frames.join(""), { headers: { ...headers, "content-type": "text/event-stream" } });
+}
+
+// src/product-models.ts
+import { z as z3 } from "zod";
+var Message = z3.object({
+  role: z3.enum(["system", "user", "assistant"]),
+  content: z3.string().max(2e5)
+}).strict();
+var Input = z3.object({
+  prompt: z3.string().max(2e5).optional(),
+  messages: z3.array(Message).min(1).max(128).optional(),
+  temperature: z3.number().min(0).max(2).optional(),
+  maxTokens: z3.number().int().min(1).max(4096).optional()
+}).strict().refine(
+  (v) => v.prompt !== void 0 !== (v.messages !== void 0),
+  "Supply prompt or messages, exclusively."
+);
+var ProductModel = class {
+  constructor(binding, connection) {
+    this.connection = connection;
+    this.id = z3.string().trim().regex(/^[a-z0-9][a-z0-9._:-]{2,127}$/).parse(typeof binding === "string" ? binding : binding.id);
+    this.capabilities = {
+      streaming: true,
+      tools: false,
+      structuredOutput: false,
+      ...typeof binding === "string" ? {} : binding.capabilities
+    };
+    if (!connection.apiKey.trim())
+      throw new Error("Named models require an API key.");
+    this.connection = {
+      ...connection,
+      baseUrl: productModelEndpoint(
+        connection.baseUrl ?? DEFAULT_MODEL_BASE_URL
+      )
+    };
+    if (connection.timeoutMs !== void 0 && (!Number.isFinite(connection.timeoutMs) || connection.timeoutMs <= 0 || connection.timeoutMs > 63e4))
+      throw new Error(
+        "Serving timeoutMs must be greater than zero and at most 630000."
+      );
+    this.transport = new ProductModelTransport(this.id, this.connection);
+  }
+  connection;
+  id;
+  capabilities;
+  transport;
+  /** Provider integrations use the same exact destination and transport. */
+  providerConnection() {
+    return { ...this.connection };
+  }
+  async request(input, stream) {
+    if (stream && !this.capabilities.streaming)
+      throw new ProductModelError("streaming_unsupported", 0, false);
+    const { signal, clientRequestId: suppliedClientId, ...raw } = input;
+    const parsed = Input.parse(raw);
+    const body = JSON.stringify({
+      model: this.id,
+      messages: parsed.messages ?? [{ role: "user", content: parsed.prompt }],
+      ...parsed.temperature === void 0 ? {} : { temperature: parsed.temperature },
+      ...parsed.maxTokens === void 0 ? {} : { max_tokens: parsed.maxTokens },
+      stream
+    });
+    return this.transport.request(body, { stream, signal, clientRequestId: suppliedClientId });
+  }
+  async generate(input) {
+    const response = await this.request(input, false);
+    try {
+      const chunk = ProductModelChunkSchema.parse(
+        await readBoundedJsonResponse(
+          response,
+          8 * 1024 * 1024,
+          "Model result"
+        )
+      );
+      if (chunk.choices.length !== 1 || !chunk.choices[0].message || chunk.choices[0].message.tool_calls)
+        throw new Error("Unsupported response");
+      return this.result(
+        chunk,
+        chunk.choices[0].message.content ?? "",
+        chunk.choices[0].finish_reason ?? null,
+        response
+      );
+    } catch {
+      throw new ProductModelError(
+        "model_response_invalid",
+        response.status,
+        true,
+        response.headers.get("x-openpond-request-id") ?? response.headers.get("x-request-id") ?? void 0,
+        this.transport.identity(response).clientRequestId
+      );
+    }
+  }
+  /** Read only: a timeout never submits another paid operation. */
+  async inspectRequest(requestId) {
+    return this.projectStatus(await this.transport.inspectRequest(requestId));
+  }
+  async recover(clientRequestId) {
+    return this.projectStatus(await this.transport.recover(clientRequestId));
+  }
+  projectStatus(status) {
+    if (!status.result) return { ...status, result: null };
+    const message = status.result.choices[0].message;
+    let toolCalls;
+    if (message.tool_calls !== void 0 && message.tool_calls !== null) {
+      const parsed = z3.array(ProductModelToolCallSchema).safeParse(message.tool_calls);
+      if (!this.capabilities.tools || !parsed.success)
+        throw new ProductModelError(
+          "model_response_invalid",
+          200,
+          true,
+          status.requestId,
+          status.clientRequestId ?? void 0
+        );
+      toolCalls = parsed.data;
+    }
+    return { ...status, result: {
+      ...this.result(
+        status.result,
+        message.content ?? "",
+        status.result.choices[0].finish_reason ?? null,
+        new Response(null)
+      ),
+      ...toolCalls === void 0 ? {} : { toolCalls }
+    } };
+  }
+  /** Explicit cancellation retains the original request's cleanup owner. */
+  async cancelRequest(requestId) {
+    await this.transport.cancelRequest(requestId);
+  }
+  result(chunk, text, finishReason, response) {
+    return {
+      text,
+      requestId: response.headers.get("x-openpond-request-id") ?? response.headers.get("x-request-id") ?? chunk.id,
+      modelId: this.id,
+      resolvedModelId: chunk.model,
+      finishReason,
+      usage: chunk.usage ? {
+        inputTokens: chunk.usage.prompt_tokens,
+        outputTokens: chunk.usage.completion_tokens,
+        totalTokens: chunk.usage.total_tokens
+      } : null,
+      systemFingerprint: chunk.system_fingerprint ?? null,
+      evidence: chunk.openpond ?? null
+    };
+  }
+  /** Breaking iteration cancels the HTTP body. A truncated stream never produces finish. */
+  async *stream(input) {
+    const response = await this.request(input, true);
+    if (!response.headers.get("content-type")?.includes("text/event-stream") || !response.body) {
+      await response.body?.cancel();
+      throw new ProductModelError(
+        "model_stream_invalid",
+        response.status,
+        true,
+        response.headers.get("x-openpond-request-id") ?? void 0,
+        this.transport.identity(response).clientRequestId
+      );
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "", text = "", finish = null, last;
+    let usage = null;
+    let outputBytes = 0;
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        buffer = (buffer + decoder.decode(value, { stream: !done })).replace(
+          /\r\n/g,
+          "\n"
+        );
+        if (new TextEncoder().encode(buffer).length > 1024 * 1024)
+          throw new Error("Stream frame too large");
+        let boundary;
+        while ((boundary = buffer.indexOf("\n\n")) >= 0) {
+          const frame = buffer.slice(0, boundary);
+          buffer = buffer.slice(boundary + 2);
+          const data = frame.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+          if (!data) continue;
+          if (data === "[DONE]") {
+            if (!last || !finish) throw new Error("Incomplete stream");
+            yield {
+              type: "finish",
+              result: this.result({ ...last, usage }, text, finish, response)
+            };
+            return;
+          }
+          const chunk = ProductModelChunkSchema.parse(JSON.parse(data));
+          if (last && (last.id !== chunk.id || last.model !== chunk.model))
+            throw new Error("Stream identity changed");
+          last = chunk;
+          if (chunk.usage) usage = chunk.usage;
+          const choice = chunk.choices[0];
+          if (choice?.delta?.tool_calls)
+            throw new Error("Tool output unsupported by text API");
+          if (choice?.finish_reason) finish = choice.finish_reason;
+          const delta = choice?.delta?.content;
+          if (delta) {
+            text += delta;
+            outputBytes += new TextEncoder().encode(delta).length;
+            if (outputBytes > 8 * 1024 * 1024)
+              throw new Error("Model output too large");
+            yield { type: "text", text: delta };
+          }
+        }
+        if (done) throw new Error("Stream ended before DONE");
+      }
+    } catch (error) {
+      if (error instanceof ProductModelError) throw error;
+      throw new ProductModelError(
+        "model_stream_interrupted",
+        response.status,
+        true,
+        response.headers.get("x-openpond-request-id") ?? response.headers.get("x-request-id") ?? void 0,
+        this.transport.identity(response).clientRequestId
+      );
+    } finally {
+      await reader.cancel().catch(() => {
+      });
+      reader.releaseLock();
+    }
+  }
+};
+function createProductModels(bindings, connection) {
+  return Object.fromEntries(
+    Object.entries(bindings).map(([name, binding]) => [
+      name,
+      new ProductModel(binding, connection)
+    ])
+  );
+}
+
+export {
+  ProductModelError,
+  productModelEndpoint,
+  ProductModelTransport,
+  ProductModel,
+  createProductModels
+};
+//# sourceMappingURL=chunk-ON3KSXWR.js.map