openpond-sdk 0.12.20 → 0.12.22

package/OPENTELEMETRY.md

@@ -0,0 +1,85 @@
+# Optional OpenTelemetry integration
+
+`openpond-sdk/opentelemetry` implements the standard JavaScript
+[`SpanExporter`](https://open-telemetry.github.io/opentelemetry-js/modules/_opentelemetry_sdk-trace.html)
+interface. Install the current tracing SDK alongside OpenPond:
+
+```sh
+npm install openpond-sdk @opentelemetry/api @opentelemetry/sdk-trace@^3.1.0
+```
+
+This is an adapter into the structured [addTask API](./TASK_INGESTION.md), not an
+OTLP receiver. Existing automatic instrumentation can produce the spans. Register
+this exporter in your existing OTel configuration, alongside your observability
+exporter if desired. It does not replace the global provider, install framework
+instrumentation, or automatically create training tasks from every log line.
+
+```ts
+import { OpenPondClient } from "openpond-sdk";
+import { OpenPondSpanExporter } from "openpond-sdk/opentelemetry";
+import { BatchSpanProcessor, TracerProvider } from "@opentelemetry/sdk-trace";
+
+const client = new OpenPondClient({ baseUrl: apiBaseUrl, apiKey, teamId });
+const exporter = new OpenPondSpanExporter({
+  client,
+  datasetId,
+  maxExportBatchSize: 32,
+  projectSpan(span) {
+    // These are application-owned attributes: explicitly mark selected agent runs.
+    if (span.attributes["app.learning_task"] !== true) return null;
+    const input = span.attributes["app.sanitized_task_input"];
+    if (typeof input !== "string" || !input.trim()) return null;
+    return {
+      name: span.name,
+      input: { prompt: input },
+      // Preserve for review; upload does not authorize training.
+      split: "validation",
+    };
+  },
+});
+const processor = new BatchSpanProcessor({
+  exporter,
+  maxExportBatchSize: 32,
+  maxQueueSize: 256,
+  exportTimeoutMillis: 30_000,
+});
+// If your application already has a provider, configure its processor list there.
+const provider = new TracerProvider({ spanProcessors: [processor] });
+const tracer = provider.getTracer("production-agent");
+// Use tracer in your agent, or your existing framework instrumentation.
+// At graceful application shutdown:
+await provider.shutdown();
+// exporter.lastExportError exposes the latest batch failure, if any.
+```
+
+Only the returned task and trace/span source IDs are uploaded. Prompts, outputs,
+attributes, exceptions and events are not copied implicitly. Redact secrets before
+returning content. A selected span should contain the context needed to reproduce
+a useful task; logs and exceptions can supply that context through span events in
+your projection. Standalone log, metrics and OTLP ingestion are not implemented.
+These examples use application attributes, not unsettled GenAI convention names.
+
+The exporter derives a dataset-scoped idempotency key from trace ID and span ID.
+Duplicate spans in a successful batch are skipped. Replaying a span after a lost
+reply uses the same key. Keep projections deterministic for a span: a changed
+payload with an existing key is a conflict, not a second task. Saved tasks still
+require the application's separate review and training authorization.
+
+Use `BatchSpanProcessor` for its bounded background queue; ending a span must not
+wait for an HTTP write. Queues can drop spans when full. The adapter sends selected
+tasks sequentially, rejects oversized/concurrent export batches, and has a 10s
+per-request and 25s overall batch deadline by default. Configure small batches for
+your network latency. HTTP failures, invalid projections and receipt mismatches
+produce OTel export failure with bounded trace/span failure details in
+`OpenPondSpanExportError.failures`. No retry worker or persistent outbox is created;
+OTel's processor does not guarantee retries or durable delivery. Use direct
+`addTask` with your own durable queue when loss is unacceptable.
+
+`forceFlush()` waits for the exporter's current HTTP work; flush the **provider**
+to drain its processor queue. `shutdown()` rejects new exports and waits for
+accepted work. A successful flush means the queue was drained, not that every
+write succeeded: inspect exporter errors/OTel diagnostics. Keep credentials on the
+server and do not change providers or close dependencies while exports are active.
+
+Python has the matching optional exporter in `ponder_sdk.opentelemetry`; see the
+[Python SDK README](../../python/openpond-sdk/README.md).

package/README.md

@@ -389,3 +389,7 @@ is immutable and owner-scoped. `comparisonBudget(id)` returns each operation's
 run ID, known settled spend, pending reservations and remaining allowance.
 Registering a comparison does not start any work. Independent experiments do
 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.

package/TASK_INGESTION.md

@@ -0,0 +1,135 @@
+# 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.
+
+Create or choose an editable Dataset in Console and copy its ID. Configure the
+server-side SDK with the workspace that owns it:
+
+```ts
+import { createOpenPondClient } from "openpond-sdk";
+
+const client = createOpenPondClient({
+  apiKey: process.env.OPENPOND_API_KEY!,
+  teamId: process.env.OPENPOND_TEAM_ID!,
+});
+
+const receipt = await client.addTask(process.env.OPENPOND_DATASET_ID!, {
+  name: "Handle an expired API token",
+  input: { request: "Fetch the report", observedError: "Token expired" },
+  source: { kind: "production_agent", eventId: "run-123" },
+}, { idempotencyKey: "run-123" });
+
+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
+
+```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({
+  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.
+
+## Input and receipt
+
+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.
+
+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.
+
+## 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.
+
+```ts
+import { DatasetTaskIngestionError } from "openpond-sdk";
+
+try {
+  await addTask(task, { idempotencyKey: sourceEventId });
+} catch (error) {
+  if (error instanceof DatasetTaskIngestionError && error.outcomeUnknown) {
+    // Retain task + error.operationId 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.
+
+## Python
+
+The maintained `ponder-sdk` package exposes the same operation on `Client`
+and `AsyncClient`:
+
+```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,
+    )
+```
+
+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.
+
+## OpenTelemetry
+
+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.

package/TRAINING_WORKFLOWS.md

@@ -54,6 +54,20 @@ execution location. Training authoring uses `trainingForm`. Cleared evaluation
 numeric controls remain `null`; blank training spend fields remain strings.
 These incomplete values can be retained without becoming executable requests.
 
+Model setup authoring may also retain optional `modelSetup` metadata, exported
+as `ModelSetupDraftSchema` and `ModelSetupDraft` from `openpond-sdk/training`.
+It stores the selected workflow (`sft`, `rl`, `decision`), adapter (`lora`,
+`engram`, `neuron-training`), `continualLearning` choice, current setup section
+and an optional editable Dataset `{ id, revision }`. That Dataset reference is
+an authoring destination, not an admitted training batch or immutable release.
+These choices survive the same revisioned draft save/read lifecycle. They do
+not publish a learning policy or establish executor compatibility. Call
+`assertModelSetupExecutionIntent(draft, requestedOperation)` when converting a
+retained setup draft into a preparation request. It rejects a different or
+unsupported workflow/adapter operation; executor admission still owns runtime,
+permissions and resource checks. Direct explicit-method APIs remain independent
+of this authoring metadata.
+
 Use `training.saveExperimentDraft(request)` with
 `schemaVersion: "openpond.experimentDraftSave.v1"`, `teamId`, a stable
 `operationId`, `expectedRevision`, optional `projectId`, and an

package/dist/advanced-refiner-evaluations.js

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

package/dist/{chunk-RN5MK7NH.js → chunk-6EZAGTZG.js}

@@ -1,12 +1,12 @@
-import {
-  ExperimentImprovementOptionsSchema
-} from "./chunk-QNOCM5JX.js";
 import {
   EvaluationCoordinationTransport
 } from "./chunk-3B5KSH3V.js";
 import {
   ChatModelRefSchema
 } from "./chunk-H3367ISL.js";
+import {
+  ExperimentImprovementOptionsSchema
+} from "./chunk-QNOCM5JX.js";
 import {
   ImmutableReleaseRefSchema,
   contentHash
@@ -264,4 +264,4 @@ export {
   AdvancedRefinerEvaluationAccountingSchema,
   OpenPondAdvancedRefinerEvaluationClient
 };
-//# sourceMappingURL=chunk-RN5MK7NH.js.map
+//# sourceMappingURL=chunk-6EZAGTZG.js.map

package/dist/{chunk-3MDNVNBM.js → chunk-BNBPKCIR.js}

@@ -1,8 +1,3 @@
-import {
-  materializePortableTasksetRelease,
-  portableTasksetEnvironment,
-  projectPortableTaskRecord
-} from "./chunk-GWXJSBWR.js";
 import {
   decodeTasksetDraftWorkspaceFile,
   isManagedTasksetDraftFilePath,
@@ -10,6 +5,11 @@ import {
   renderTasksetDraftManifests,
   validateTasksetDraftWorkspace
 } from "./chunk-Q4RGCEOI.js";
+import {
+  materializePortableTasksetRelease,
+  portableTasksetEnvironment,
+  projectPortableTaskRecord
+} from "./chunk-GWXJSBWR.js";
 import {
   TasksetSchema,
   computeTasksetHash
@@ -471,4 +471,4 @@ export {
   compileTasksetDraftWorkspace,
   compileModelTasksetDraftWorkspace
 };
-//# sourceMappingURL=chunk-3MDNVNBM.js.map
+//# sourceMappingURL=chunk-BNBPKCIR.js.map

package/dist/chunk-NZRGRUYG.js

@@ -0,0 +1,140 @@
+import {
+  readBoundedJsonResponse
+} from "./chunk-B3ZHJ2KK.js";
+
+// src/dataset-task-ingestion.ts
+import { z } from "zod";
+import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
+var Id = z.string().trim().min(1).max(240);
+var DatasetTaskInputSchema = z.object({
+  name: z.string().trim().min(1).max(300),
+  input: z.record(z.string(), z.unknown()),
+  expectedOutput: z.record(z.string(), z.unknown()).nullable().default(null),
+  split: z.enum(["train", "validation", "frozen_eval"]).default("validation"),
+  source: z.object({
+    kind: z.string().trim().min(1).max(100),
+    eventId: Id.optional(),
+    label: z.string().trim().min(1).max(300).optional(),
+    occurredAt: z.iso.datetime().optional()
+  }).strict().optional(),
+  tags: z.array(Id).max(100).default([])
+}).strict();
+var DatasetTaskAppendRequestSchema = z.object({
+  schemaVersion: z.literal("openpond.datasetTaskAppend.v1"),
+  operationId: Id,
+  task: DatasetTaskInputSchema
+}).strict();
+var DatasetTaskAppendReceiptSchema = z.object({
+  schemaVersion: z.literal("openpond.datasetTaskReceipt.v1"),
+  teamId: Id,
+  datasetId: z.string().trim().min(1).max(240),
+  taskId: Id,
+  operationId: Id,
+  receivedAt: z.iso.datetime(),
+  revision: z.number().int().positive(),
+  state: z.literal("saved"),
+  trainingUseAuthorized: z.literal(false)
+}).strict();
+var DatasetTaskIngestionError = class extends Error {
+  constructor(message, status, code, operationId) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.operationId = operationId;
+    this.name = "DatasetTaskIngestionError";
+    this.outcomeUnknown = status === 0 || status >= 500 || code === "dataset_task_receipt_invalid";
+  }
+  status;
+  code;
+  operationId;
+  outcomeUnknown;
+};
+async function addDatasetTask(config, datasetId, task, options = {}) {
+  const url = new URL(config.baseUrl);
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash || url.pathname !== "/")
+    throw new Error("A clean API origin is required.");
+  const teamId = Id.parse(config.teamId);
+  if (!config.apiKey.trim()) throw new Error("An OpenPond API key is required.");
+  const id = z.string().trim().min(1).max(240).parse(datasetId);
+  const request = DatasetTaskAppendRequestSchema.parse({
+    schemaVersion: "openpond.datasetTaskAppend.v1",
+    operationId: options.idempotencyKey ?? crypto.randomUUID(),
+    task
+  });
+  assertBoundedTaskJson(request, 128 * 1024);
+  let response;
+  try {
+    response = await (config.fetch ?? fetch)(
+      `${url.origin}/v1/dataset-workspaces/${encodeURIComponent(id)}/tasks`,
+      {
+        method: "POST",
+        redirect: "error",
+        signal: options.signal,
+        headers: {
+          Authorization: `Bearer ${config.apiKey}`,
+          "X-OpenPond-Team-Id": teamId,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(request)
+      }
+    );
+  } catch {
+    throw new DatasetTaskIngestionError(
+      "Task delivery could not be confirmed. Retry with the same operation ID.",
+      0,
+      "dataset_task_outcome_unknown",
+      request.operationId
+    );
+  }
+  let raw;
+  try {
+    raw = await readBoundedJsonResponse(response, 64 * 1024, "Dataset task receipt");
+  } catch {
+    throw new DatasetTaskIngestionError(
+      "Task delivery returned an invalid receipt. Retain the same operation ID before retrying.",
+      response.status,
+      "dataset_task_receipt_invalid",
+      request.operationId
+    );
+  }
+  if (!response.ok) {
+    const error = z.object({ message: z.string().optional(), code: z.string().optional() }).passthrough().safeParse(raw);
+    throw new DatasetTaskIngestionError(
+      error.success ? error.data.message ?? "Task submission failed." : "Task submission failed.",
+      response.status,
+      error.success ? error.data.code ?? "dataset_task_request_failed" : "dataset_task_request_failed",
+      request.operationId
+    );
+  }
+  const parsed = DatasetTaskAppendReceiptSchema.safeParse(raw);
+  if (!parsed.success)
+    throw new DatasetTaskIngestionError(
+      "Task delivery returned an invalid receipt.",
+      response.status,
+      "dataset_task_receipt_invalid",
+      request.operationId
+    );
+  const receipt = parsed.data;
+  if (receipt.teamId !== teamId || receipt.datasetId !== id || receipt.operationId !== request.operationId)
+    throw new DatasetTaskIngestionError(
+      "Dataset task receipt identity mismatch.",
+      response.status,
+      "dataset_task_receipt_invalid",
+      request.operationId
+    );
+  return receipt;
+}
+function createTaskAdder(config) {
+  const { datasetId, ...connection } = config;
+  return (task, options) => addDatasetTask(connection, datasetId, task, options);
+}
+
+export {
+  DatasetTaskInputSchema,
+  DatasetTaskAppendRequestSchema,
+  DatasetTaskAppendReceiptSchema,
+  DatasetTaskIngestionError,
+  addDatasetTask,
+  createTaskAdder
+};
+//# sourceMappingURL=chunk-NZRGRUYG.js.map

package/dist/chunk-NZRGRUYG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/dataset-task-ingestion.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { assertBoundedTaskJson } from \"@openpond/evals/task-schema\";\nimport { readBoundedJsonResponse } from \"./protocol.js\";\n\nconst Id = z.string().trim().min(1).max(240);\nexport const DatasetTaskInputSchema = z\n  .object({\n    name: z.string().trim().min(1).max(300),\n    input: z.record(z.string(), z.unknown()),\n    expectedOutput: z.record(z.string(), z.unknown()).nullable().default(null),\n    split: z.enum([\"train\", \"validation\", \"frozen_eval\"]).default(\"validation\"),\n    source: z\n      .object({\n        kind: z.string().trim().min(1).max(100),\n        eventId: Id.optional(),\n        label: z.string().trim().min(1).max(300).optional(),\n        occurredAt: z.iso.datetime().optional(),\n      })\n      .strict()\n      .optional(),\n    tags: z.array(Id).max(100).default([]),\n  })\n  .strict();\nexport const DatasetTaskAppendRequestSchema = z\n  .object({\n    schemaVersion: z.literal(\"openpond.datasetTaskAppend.v1\"),\n    operationId: Id,\n    task: DatasetTaskInputSchema,\n  })\n  .strict();\nexport const DatasetTaskAppendReceiptSchema = z\n  .object({\n    schemaVersion: z.literal(\"openpond.datasetTaskReceipt.v1\"),\n    teamId: Id,\n    datasetId: z.string().trim().min(1).max(240),\n    taskId: Id,\n    operationId: Id,\n    receivedAt: z.iso.datetime(),\n    revision: z.number().int().positive(),\n    state: z.literal(\"saved\"),\n    trainingUseAuthorized: z.literal(false),\n  })\n  .strict();\nexport type DatasetTaskInput = z.input<typeof DatasetTaskInputSchema>;\nexport type DatasetTaskAppendReceipt = z.infer<typeof DatasetTaskAppendReceiptSchema>;\nexport type AddTaskOptions = { idempotencyKey?: string; signal?: AbortSignal };\nexport type DatasetTaskClientOptions = {\n  apiKey: string;\n  baseUrl: string;\n  teamId: string;\n  fetch?: typeof fetch;\n};\n\nexport class DatasetTaskIngestionError extends Error {\n  readonly outcomeUnknown: boolean;\n  constructor(\n    message: string,\n    readonly status: number,\n    readonly code: string,\n    readonly operationId: string,\n  ) {\n    super(message);\n    this.name = \"DatasetTaskIngestionError\";\n    this.outcomeUnknown = status === 0 || status >= 500 || code === \"dataset_task_receipt_invalid\";\n  }\n}\n\n/** A bounded append, independent of complete workspace downloads or replacement. */\nexport async function addDatasetTask(\n  config: DatasetTaskClientOptions,\n  datasetId: string,\n  task: DatasetTaskInput,\n  options: AddTaskOptions = {},\n): Promise<DatasetTaskAppendReceipt> {\n  const url = new URL(config.baseUrl);\n  if (\n    ![\"http:\", \"https:\"].includes(url.protocol) ||\n    url.username ||\n    url.password ||\n    url.search ||\n    url.hash ||\n    url.pathname !== \"/\"\n  )\n    throw new Error(\"A clean API origin is required.\");\n  const teamId = Id.parse(config.teamId);\n  if (!config.apiKey.trim()) throw new Error(\"An OpenPond API key is required.\");\n  const id = z.string().trim().min(1).max(240).parse(datasetId);\n  const request = DatasetTaskAppendRequestSchema.parse({\n    schemaVersion: \"openpond.datasetTaskAppend.v1\",\n    operationId: options.idempotencyKey ?? crypto.randomUUID(),\n    task,\n  });\n  assertBoundedTaskJson(request, 128 * 1024);\n  let response: Response;\n  try {\n    response = await (config.fetch ?? fetch)(\n      `${url.origin}/v1/dataset-workspaces/${encodeURIComponent(id)}/tasks`,\n      {\n        method: \"POST\",\n        redirect: \"error\",\n        signal: options.signal,\n        headers: {\n          Authorization: `Bearer ${config.apiKey}`,\n          \"X-OpenPond-Team-Id\": teamId,\n          \"Content-Type\": \"application/json\",\n        },\n        body: JSON.stringify(request),\n      },\n    );\n  } catch {\n    throw new DatasetTaskIngestionError(\n      \"Task delivery could not be confirmed. Retry with the same operation ID.\",\n      0,\n      \"dataset_task_outcome_unknown\",\n      request.operationId,\n    );\n  }\n  let raw: unknown;\n  try {\n    raw = await readBoundedJsonResponse(response, 64 * 1024, \"Dataset task receipt\");\n  } catch {\n    throw new DatasetTaskIngestionError(\n      \"Task delivery returned an invalid receipt. Retain the same operation ID before retrying.\",\n      response.status,\n      \"dataset_task_receipt_invalid\",\n      request.operationId,\n    );\n  }\n  if (!response.ok) {\n    const error = z\n      .object({ message: z.string().optional(), code: z.string().optional() })\n      .passthrough()\n      .safeParse(raw);\n    throw new DatasetTaskIngestionError(\n      error.success ? (error.data.message ?? \"Task submission failed.\") : \"Task submission failed.\",\n      response.status,\n      error.success\n        ? (error.data.code ?? \"dataset_task_request_failed\")\n        : \"dataset_task_request_failed\",\n      request.operationId,\n    );\n  }\n  const parsed = DatasetTaskAppendReceiptSchema.safeParse(raw);\n  if (!parsed.success)\n    throw new DatasetTaskIngestionError(\n      \"Task delivery returned an invalid receipt.\",\n      response.status,\n      \"dataset_task_receipt_invalid\",\n      request.operationId,\n    );\n  const receipt = parsed.data;\n  if (\n    receipt.teamId !== teamId ||\n    receipt.datasetId !== id ||\n    receipt.operationId !== request.operationId\n  )\n    throw new DatasetTaskIngestionError(\n      \"Dataset task receipt identity mismatch.\",\n      response.status,\n      \"dataset_task_receipt_invalid\",\n      request.operationId,\n    );\n  return receipt;\n}\n\n/** Bind credentials and destination once; the returned addTask has no global state. */\nexport function createTaskAdder(config: DatasetTaskClientOptions & { datasetId: string }) {\n  const { datasetId, ...connection } = config;\n  return (task: DatasetTaskInput, options?: AddTaskOptions) =>\n    addDatasetTask(connection, datasetId, task, options);\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-RT7SQHO4.js → chunk-SP7DQEQM.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-GPQLBVQC.js";
 import {
   AuthoredTasksetFileInventorySchema
-} from "./chunk-3MDNVNBM.js";
+} from "./chunk-BNBPKCIR.js";
 import {
   configuredTasksetDraftFiles,
   createTasksetDraftWorkspace,
@@ -698,4 +698,4 @@ export {
   prepareTasksetDraftSource,
   materializeTasksetDraftWorkspace
 };
-//# sourceMappingURL=chunk-RT7SQHO4.js.map
+//# sourceMappingURL=chunk-SP7DQEQM.js.map

package/dist/connected-evidence.js

@@ -49,15 +49,15 @@ import {
   ConnectedStartingAssetsRequestSchema,
   verifyConnectedStartingAssetsReceipt
 } from "./chunk-AG6UJ3DI.js";
-import "./chunk-3MDNVNBM.js";
-import "./chunk-GWXJSBWR.js";
+import "./chunk-BNBPKCIR.js";
 import "./chunk-Q4RGCEOI.js";
+import "./chunk-GWXJSBWR.js";
 import "./chunk-GCUWJUUM.js";
 import {
   ConnectedDatasetSourceRefSchema
 } from "./chunk-ZQ6QTYRE.js";
-import "./chunk-Z252BNAZ.js";
 import "./chunk-TK3DXH7A.js";
+import "./chunk-Z252BNAZ.js";
 import "./chunk-H3367ISL.js";
 import "./chunk-O6FKHAWN.js";
 import "./chunk-QTNYXOJW.js";