openpond-sdk 0.1.1 → 0.1.3

package/LEARNING.md

@@ -42,3 +42,9 @@ historical batches.
 All client requests support an optional `AbortSignal`. Aborting a request does
 not cancel remote compute; use `cancel_grade` and read the authoritative terminal
 job state. Page through list responses with `nextCursor` as `afterId`.
+
+## Publish a reviewed batch to a hosted model
+
+Call `learning.publishBatch({ batchId, modelProjectId })` against the hosted API after sealing an approved batch. This stores its immutable Taskset package and attaches the exact release to the model. It does not start training. The service authorizes the model and batch in the same team and deduplicates publication by release identity.
+
+Model configuration can save `trainingSetup.rewardBindingRef` before selecting a Taskset. The reference pins a binding ID, revision and content hash; task compatibility and training readiness remain separate checks. Use `createModelProjectSaveRequest` with `createModelProjectsClient().checkConfiguration()` / `.saveConfiguration()` for hosted configuration operations, and `configurationCandidates()` for available starting models. Keep one request identity for transport retries.

package/TASKSETS.md

@@ -0,0 +1,31 @@
+# Published Taskset inventory
+
+`openpond-sdk/taskset-catalog` provides authenticated, paginated metadata reads
+for the selected hosted workspace. The service applies workspace access and
+optional Model Project attachment filtering before returning records.
+
+```ts
+import { OpenPondTasksetCatalogClient } from "openpond-sdk/taskset-catalog";
+
+const tasksets = new OpenPondTasksetCatalogClient({
+  baseUrl: "https://api.openpond.ai",
+  apiKey,
+  teamId,
+});
+const page = await tasksets.list({ limit: 30, modelProjectId });
+const item = await tasksets.get(page.items[0].id);
+const selected = await tasksets.resolve(item.release);
+const next = page.nextCursor
+  ? await tasksets.list({ limit: 30, modelProjectId, afterId: page.nextCursor })
+  : null;
+```
+
+The item's `id` is the hosted inventory identity. Its `release` pins the portable
+ID, revision and content hash used in model configuration. Metadata reads contain
+no task rows, private verifier source or object-store locations. Publication and
+package byte counts do not establish grading or training readiness.
+
+The client rejects responses for a different workspace or requested resource,
+limits catalog responses to 4 MiB, supports abort signals, and does not follow
+redirects with credentials. `OpenPondTasksetCatalogError` preserves HTTP status and
+the service's error code.

package/dist/index.js

@@ -2708,6 +2708,8 @@ function requiredId(value, label) {
 // src/learning.ts
 var learning_exports = {};
 __export(learning_exports, {
+  LearningBatchPublicationResultSchema: () => LearningBatchPublicationResultSchema,
+  LearningBatchPublicationSchema: () => LearningBatchPublicationSchema,
   OpenPondLearningClient: () => OpenPondLearningClient,
   OpenPondLearningError: () => OpenPondLearningError
 });
@@ -2724,6 +2726,18 @@ import {
 import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
 import * as learning_star from "@openpond/evals/learning";
 import * as rewards_star from "@openpond/evals/rewards";
+var LearningBatchPublicationSchema = z.object({
+  batchId: z.string().trim().min(1).max(500),
+  modelProjectId: z.string().trim().min(1).max(500)
+}).strict();
+var LearningBatchPublicationResultSchema = z.object({
+  batchId: z.string().min(1),
+  projectId: z.string().min(1),
+  tasksetId: z.string().min(1),
+  releaseId: z.string().min(1),
+  revision: z.number().int().positive(),
+  contentHash: z.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
 var OpenPondLearningError = class extends Error {
   constructor(status, code, message, details) {
     super(message);
@@ -2765,6 +2779,13 @@ var OpenPondLearningClient = class {
     const request = LearningReadRequestSchema.parse({ action: "list", scope: this.#options.scope, kind, ...query });
     return z.object({ items: z.array(learningResourceSchemas[kind]).max(100), nextCursor: z.string().nullable() }).strict().parse(await this.#request("read", request, options));
   }
+  /** Hosted publication only: stores an immutable package and attaches it, without starting training. */
+  async publishBatch(input, options = {}) {
+    const request = LearningBatchPublicationSchema.parse(input);
+    const result = LearningBatchPublicationResultSchema.parse(await this.#request("publish-batch", { ...request, scope: this.#options.scope }, options));
+    if (result.batchId !== request.batchId) throw new OpenPondLearningError(502, "batch_identity_mismatch", "Published batch response did not match the requested batch.", null);
+    return result;
+  }
   async #request(endpoint, body, options) {
     assertBoundedTaskJson(body, 16777216);
     const response = await (this.#options.fetch ?? globalThis.fetch)(`${this.#options.baseUrl}/v1/learning/${endpoint}`, {