openpond-sdk 0.0.18 → 0.1.0

package/dist/index.js

@@ -1,3 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
 // ../cloud/dist/sandbox/client-handles.js
 function createSandboxRuntimeNamespace(client) {
   return {
@@ -2687,13 +2705,115 @@ function requiredId(value, label) {
   return normalized;
 }
 
-// ../../node_modules/.pnpm/@openpond+harness@0.2.5/node_modules/@openpond/harness/dist/refiner.js
-import { z as z3 } from "zod";
-
-// ../../node_modules/.pnpm/@openpond+harness@0.2.5/node_modules/@openpond/harness/dist/common.js
+// src/learning.ts
+var learning_exports = {};
+__export(learning_exports, {
+  OpenPondLearningClient: () => OpenPondLearningClient,
+  OpenPondLearningError: () => OpenPondLearningError
+});
+__reExport(learning_exports, learning_star);
+__reExport(learning_exports, rewards_star);
 import { z } from "zod";
+import {
+  LearningCommandRequestSchema,
+  LearningOperationResultSchema,
+  LearningReadRequestSchema,
+  assertLearningRequestJson,
+  learningResourceSchemas
+} from "@openpond/evals/learning";
+import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
+import * as learning_star from "@openpond/evals/learning";
+import * as rewards_star from "@openpond/evals/rewards";
+var OpenPondLearningError = class extends Error {
+  constructor(status, code, message, details) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    this.name = "OpenPondLearningError";
+  }
+  status;
+  code;
+  details;
+};
+var OpenPondLearningClient = class {
+  #options;
+  constructor(options) {
+    if (!options.apiKey.trim() || !options.scope.trim()) throw new Error("Learning API key and scope are required.");
+    const url = new URL(options.baseUrl);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) throw new Error("Learning base URL must be an HTTP(S) endpoint without credentials, query, or fragment.");
+    this.#options = { ...options, baseUrl: url.toString().replace(/\/+$/, "") };
+  }
+  async command(command, options = {}) {
+    assertLearningRequestJson(command);
+    const request = LearningCommandRequestSchema.parse({ scope: this.#options.scope, command });
+    const result = LearningOperationResultSchema.parse(await this.#request("commands", request, options));
+    if (result.operationId !== command.operationId) throw new OpenPondLearningError(502, "operation_identity_mismatch", "Learning response did not match the submitted operation.", null);
+    return result;
+  }
+  submitExample(example, options = {}) {
+    return this.command({ action: "submit_example", operationId: example.idempotencyKey, example }, options);
+  }
+  submitFeedback(feedback, options = {}) {
+    return this.command({ action: "submit_feedback", operationId: feedback.idempotencyKey, feedback }, options);
+  }
+  async get(kind, id, revision, options = {}) {
+    const request = LearningReadRequestSchema.parse({ action: "get", scope: this.#options.scope, kind, id, ...revision === void 0 ? {} : { revision } });
+    return learningResourceSchemas[kind].parse(await this.#request("read", request, options));
+  }
+  async list(kind, query = {}, options = {}) {
+    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));
+  }
+  async #request(endpoint, body, options) {
+    assertBoundedTaskJson(body, 16777216);
+    const response = await (this.#options.fetch ?? globalThis.fetch)(`${this.#options.baseUrl}/v1/learning/${endpoint}`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.#options.apiKey}`, "Content-Type": "application/json", Accept: "application/json", "X-OpenPond-Team-Id": this.#options.scope },
+      body: JSON.stringify(body),
+      signal: options.signal,
+      redirect: "error"
+    });
+    const payload = await readBoundedLearningResponse(response);
+    if (!response.ok) {
+      const error = z.object({ code: z.string().optional(), error: z.string().optional() }).passthrough().safeParse(payload);
+      throw new OpenPondLearningError(response.status, error.success ? error.data.code ?? "learning_request_failed" : "learning_request_failed", error.success ? error.data.error ?? `Learning request failed (${response.status}).` : `Learning request failed (${response.status}).`, payload);
+    }
+    return payload;
+  }
+};
+async function readBoundedLearningResponse(response) {
+  const maximumBytes = 16777216;
+  const reader = response.body?.getReader();
+  if (!reader) throw new OpenPondLearningError(response.status, "empty_response", "Learning response was empty.", null);
+  const decoder = new TextDecoder();
+  let bytes = 0;
+  let text = "";
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (next.done) break;
+      bytes += next.value.byteLength;
+      if (bytes > maximumBytes) throw new OpenPondLearningError(response.status, "response_too_large", "Learning response exceeded 16 MiB; request a smaller page.", null);
+      text += decoder.decode(next.value, { stream: true });
+    }
+    text += decoder.decode();
+    const value = JSON.parse(text);
+    assertBoundedTaskJson(value, maximumBytes);
+    return value;
+  } finally {
+    await reader.cancel();
+    reader.releaseLock();
+  }
+}
+
+// ../harness/dist/refiner.js
+import { z as z4 } from "zod";
 
-// ../../node_modules/.pnpm/@openpond+harness@0.2.5/node_modules/@openpond/harness/dist/sha256.js
+// ../harness/dist/common.js
+import { z as z2 } from "zod";
+
+// ../harness/dist/sha256.js
 var INITIAL_STATE = new Uint32Array([
   1779033703,
   3144134277,
@@ -2832,32 +2952,32 @@ function rotateRight(value, bits) {
   return value >>> bits | value << 32 - bits;
 }
 
-// ../../node_modules/.pnpm/@openpond+harness@0.2.5/node_modules/@openpond/harness/dist/common.js
+// ../harness/dist/common.js
 var MAX_PORTABLE_PATH_BYTES = 2e3;
 var MAX_PORTABLE_ASSET_BYTES = 25e7;
-var ReleaseIdSchema = z.string().trim().min(1).max(240);
-var ReleaseHashSchema = z.string().regex(/^[a-f0-9]{64}$/);
-var ReleaseTimestampSchema = z.string().datetime({ offset: true });
-var MetadataSchema = z.record(z.string(), z.unknown()).default({});
-var ImmutableReleaseRefSchema = z.object({
+var ReleaseIdSchema = z2.string().trim().min(1).max(240);
+var ReleaseHashSchema = z2.string().regex(/^[a-f0-9]{64}$/);
+var ReleaseTimestampSchema = z2.string().datetime({ offset: true });
+var MetadataSchema = z2.record(z2.string(), z2.unknown()).default({});
+var ImmutableReleaseRefSchema = z2.object({
   id: ReleaseIdSchema,
   contentHash: ReleaseHashSchema
 }).strict();
-var ImmutableAssetRefSchema = z.object({
+var ImmutableAssetRefSchema = z2.object({
   id: ReleaseIdSchema,
-  path: z.string().trim().min(1).max(MAX_PORTABLE_PATH_BYTES).refine(safeRelativePath),
+  path: z2.string().trim().min(1).max(MAX_PORTABLE_PATH_BYTES).refine(safeRelativePath),
   contentHash: ReleaseHashSchema,
-  sizeBytes: z.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES),
-  mediaType: z.string().trim().min(1).max(200),
-  visibility: z.enum(["policy", "verifier", "host_private"])
+  sizeBytes: z2.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES),
+  mediaType: z2.string().trim().min(1).max(200),
+  visibility: z2.enum(["policy", "verifier", "host_private"])
 }).strict();
-var ImmutableArtifactRefSchema = z.object({
+var ImmutableArtifactRefSchema = z2.object({
   id: ReleaseIdSchema,
   contentHash: ReleaseHashSchema,
-  mediaType: z.string().trim().min(1).max(200).nullable().default(null),
-  sizeBytes: z.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES).nullable().default(null)
+  mediaType: z2.string().trim().min(1).max(200).nullable().default(null),
+  sizeBytes: z2.number().int().nonnegative().max(MAX_PORTABLE_ASSET_BYTES).nullable().default(null)
 }).strict();
-var FailureClassSchema = z.enum([
+var FailureClassSchema = z2.enum([
   "policy_failure",
   "grader_failure",
   "environment_failure",
@@ -2889,23 +3009,23 @@ function sortValue(value) {
   return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortValue(child)]));
 }
 
-// ../../node_modules/.pnpm/@openpond+harness@0.2.5/node_modules/@openpond/harness/dist/refiner-profiles.js
-import { z as z2 } from "zod";
-var RefinerProposalRouteSchema = z2.enum(["memory", "prompt", "skill", "agent"]);
-var RefinerExternalRouteSchema = z2.enum(["runtime", "product", "taskset", "training"]);
-var RefinerReviewInstructionSchema = z2.object({
-  id: z2.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
-  text: z2.string().trim().min(1).max(1e4)
+// ../harness/dist/refiner-profiles.js
+import { z as z3 } from "zod";
+var RefinerProposalRouteSchema = z3.enum(["memory", "prompt", "skill", "agent"]);
+var RefinerExternalRouteSchema = z3.enum(["runtime", "product", "taskset", "training"]);
+var RefinerReviewInstructionSchema = z3.object({
+  id: z3.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
+  text: z3.string().trim().min(1).max(1e4)
 }).strict();
-var RefinerReviewProfileSchema = z2.object({
-  schemaVersion: z2.literal("openpond.refinerReviewProfile.v1"),
-  id: z2.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
-  version: z2.string().trim().min(1).max(120),
-  name: z2.string().trim().min(1).max(200),
-  objective: z2.string().trim().min(1).max(1e4),
-  instructions: z2.array(RefinerReviewInstructionSchema).max(100),
-  allowedProposalRoutes: z2.array(RefinerProposalRouteSchema).max(4),
-  allowedExternalRoutes: z2.array(RefinerExternalRouteSchema).max(4)
+var RefinerReviewProfileSchema = z3.object({
+  schemaVersion: z3.literal("openpond.refinerReviewProfile.v1"),
+  id: z3.string().trim().min(1).max(120).regex(/^[a-z0-9][a-z0-9._-]*$/),
+  version: z3.string().trim().min(1).max(120),
+  name: z3.string().trim().min(1).max(200),
+  objective: z3.string().trim().min(1).max(1e4),
+  instructions: z3.array(RefinerReviewInstructionSchema).max(100),
+  allowedProposalRoutes: z3.array(RefinerProposalRouteSchema).max(4),
+  allowedExternalRoutes: z3.array(RefinerExternalRouteSchema).max(4)
 }).strict().superRefine((profile, context) => {
   const instructionIds = profile.instructions.map((instruction) => instruction.id);
   if (new Set(instructionIds).size !== instructionIds.length) {
@@ -2928,10 +3048,10 @@ var DEFAULT_REFINER_REVIEW_PROFILE = {
   allowedProposalRoutes: ["memory", "prompt", "skill", "agent"],
   allowedExternalRoutes: ["runtime", "product", "taskset", "training"]
 };
-var RefinerReleaseSchema = z2.object({
-  schemaVersion: z2.literal("openpond.refinerRelease.v1"),
-  id: z2.string().trim().min(1).max(240),
-  coreVersion: z2.string().trim().min(1).max(120),
+var RefinerReleaseSchema = z3.object({
+  schemaVersion: z3.literal("openpond.refinerRelease.v1"),
+  id: z3.string().trim().min(1).max(240),
+  coreVersion: z3.string().trim().min(1).max(120),
   coreHash: ReleaseHashSchema,
   profile: RefinerReviewProfileSchema,
   profileHash: ReleaseHashSchema,
@@ -2939,24 +3059,24 @@ var RefinerReleaseSchema = z2.object({
   createdAt: ReleaseTimestampSchema,
   contentHash: ReleaseHashSchema
 }).strict();
-var RefinerBindingSchema = z2.object({
-  schemaVersion: z2.literal("openpond.refinerBinding.v1"),
-  channel: z2.literal("active"),
-  revision: z2.number().int().nonnegative(),
+var RefinerBindingSchema = z3.object({
+  schemaVersion: z3.literal("openpond.refinerBinding.v1"),
+  channel: z3.literal("active"),
+  revision: z3.number().int().nonnegative(),
   release: ImmutableReleaseRefSchema,
   updatedAt: ReleaseTimestampSchema
 }).strict();
-var RefinerTransitionReceiptSchema = z2.object({
-  schemaVersion: z2.literal("openpond.refinerTransitionReceipt.v1"),
-  id: z2.string().trim().min(1).max(240),
-  operation: z2.enum(["initialize", "update", "activate", "rollback"]),
-  bindingChanged: z2.boolean(),
+var RefinerTransitionReceiptSchema = z3.object({
+  schemaVersion: z3.literal("openpond.refinerTransitionReceipt.v1"),
+  id: z3.string().trim().min(1).max(240),
+  operation: z3.enum(["initialize", "update", "activate", "rollback"]),
+  bindingChanged: z3.boolean(),
   previousRelease: ImmutableReleaseRefSchema.nullable(),
   nextRelease: ImmutableReleaseRefSchema,
-  actor: z2.string().trim().min(1).max(240),
-  reason: z2.string().trim().min(1).max(1e4),
+  actor: z3.string().trim().min(1).max(240),
+  reason: z3.string().trim().min(1).max(1e4),
   authoringSkillHash: ReleaseHashSchema.nullable(),
-  validation: z2.object({ valid: z2.boolean(), messages: z2.array(z2.string().max(2e3)).max(100) }).strict(),
+  validation: z3.object({ valid: z3.boolean(), messages: z3.array(z3.string().max(2e3)).max(100) }).strict(),
   createdAt: ReleaseTimestampSchema,
   contentHash: ReleaseHashSchema
 }).strict();
@@ -2998,32 +3118,32 @@ function serializeReviewProfile(profile) {
   return canonicalJson(RefinerReviewProfileSchema.parse(profile));
 }
 
-// ../../node_modules/.pnpm/@openpond+harness@0.2.5/node_modules/@openpond/harness/dist/refiner.js
-var RefinerNoActionDecisionSchema = z3.object({
-  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v1"),
-  decision: z3.literal("no_action"),
-  reason: z3.string().trim().min(1).max(1e4)
+// ../harness/dist/refiner.js
+var RefinerNoActionDecisionSchema = z4.object({
+  schemaVersion: z4.literal("openpond.localHarnessRefinerDecision.v1"),
+  decision: z4.literal("no_action"),
+  reason: z4.string().trim().min(1).max(1e4)
 }).strip();
-var RefinerExternalRouteDecisionSchema = z3.object({
-  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v1"),
-  decision: z3.literal("route"),
-  route: z3.enum(["runtime", "product", "taskset", "training"]),
-  summary: z3.string().trim().min(1).max(2e3),
-  expectedOutcome: z3.string().trim().min(1).max(1e4),
-  reason: z3.string().trim().min(1).max(1e4)
+var RefinerExternalRouteDecisionSchema = z4.object({
+  schemaVersion: z4.literal("openpond.localHarnessRefinerDecision.v1"),
+  decision: z4.literal("route"),
+  route: z4.enum(["runtime", "product", "taskset", "training"]),
+  summary: z4.string().trim().min(1).max(2e3),
+  expectedOutcome: z4.string().trim().min(1).max(1e4),
+  reason: z4.string().trim().min(1).max(1e4)
 }).strip();
-var RefinerProposalDecisionSchema = z3.object({
-  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v1"),
-  decision: z3.literal("propose"),
-  route: z3.enum(["memory", "prompt", "skill", "agent"]),
-  operation: z3.enum(["create", "update", "delete"]),
-  target: z3.string().trim().min(1).max(2e3),
-  summary: z3.string().trim().min(1).max(2e3),
-  createContent: z3.string().min(1).max(2e4).nullable(),
-  find: z3.string().min(1).max(8e3).nullable(),
-  replace: z3.string().max(8e3).nullable(),
-  expectedOutcome: z3.string().trim().min(1).max(1e4),
-  reason: z3.string().trim().min(1).max(1e4)
+var RefinerProposalDecisionSchema = z4.object({
+  schemaVersion: z4.literal("openpond.localHarnessRefinerDecision.v1"),
+  decision: z4.literal("propose"),
+  route: z4.enum(["memory", "prompt", "skill", "agent"]),
+  operation: z4.enum(["create", "update", "delete"]),
+  target: z4.string().trim().min(1).max(2e3),
+  summary: z4.string().trim().min(1).max(2e3),
+  createContent: z4.string().min(1).max(2e4).nullable(),
+  find: z4.string().min(1).max(8e3).nullable(),
+  replace: z4.string().max(8e3).nullable(),
+  expectedOutcome: z4.string().trim().min(1).max(1e4),
+  reason: z4.string().trim().min(1).max(1e4)
 }).strip().superRefine((decision, context) => {
   if (decision.operation === "create" && (decision.createContent === null || decision.find !== null || decision.replace !== null)) {
     context.addIssue({
@@ -3047,16 +3167,16 @@ var RefinerProposalDecisionSchema = z3.object({
     });
   }
 });
-var LocalHarnessRefinerDecisionSchema = z3.discriminatedUnion("decision", [
+var LocalHarnessRefinerDecisionSchema = z4.discriminatedUnion("decision", [
   RefinerNoActionDecisionSchema,
   RefinerExternalRouteDecisionSchema,
   RefinerProposalDecisionSchema
 ]);
 var LocalHarnessRefinerDecisionV1Schema = LocalHarnessRefinerDecisionSchema;
-var HarnessRefinerEvidenceBasisSchema = z3.object({
-  kind: z3.enum(["single_deterministic", "recurrent_independent"]),
-  supportingEvidenceIds: z3.array(z3.string().trim().min(1).max(2e3)).min(1).max(100),
-  counterevidence: z3.array(z3.string().trim().min(1).max(2e3)).max(20)
+var HarnessRefinerEvidenceBasisSchema = z4.object({
+  kind: z4.enum(["single_deterministic", "recurrent_independent"]),
+  supportingEvidenceIds: z4.array(z4.string().trim().min(1).max(2e3)).min(1).max(100),
+  counterevidence: z4.array(z4.string().trim().min(1).max(2e3)).max(20)
 }).strict().superRefine((basis, context) => {
   if (new Set(basis.supportingEvidenceIds).size !== basis.supportingEvidenceIds.length) {
     context.addIssue({
@@ -3073,33 +3193,33 @@ var HarnessRefinerEvidenceBasisSchema = z3.object({
     });
   }
 });
-var RefinerNoActionDecisionV2Schema = z3.object({
-  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v2"),
-  decision: z3.literal("no_action"),
-  reason: z3.string().trim().min(1).max(1e4)
+var RefinerNoActionDecisionV2Schema = z4.object({
+  schemaVersion: z4.literal("openpond.localHarnessRefinerDecision.v2"),
+  decision: z4.literal("no_action"),
+  reason: z4.string().trim().min(1).max(1e4)
 }).strict();
-var RefinerExternalRouteDecisionV2Schema = z3.object({
-  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v2"),
-  decision: z3.literal("route"),
-  route: z3.enum(["runtime", "product", "taskset", "training"]),
-  summary: z3.string().trim().min(1).max(2e3),
+var RefinerExternalRouteDecisionV2Schema = z4.object({
+  schemaVersion: z4.literal("openpond.localHarnessRefinerDecision.v2"),
+  decision: z4.literal("route"),
+  route: z4.enum(["runtime", "product", "taskset", "training"]),
+  summary: z4.string().trim().min(1).max(2e3),
   evidenceBasis: HarnessRefinerEvidenceBasisSchema,
-  expectedOutcome: z3.string().trim().min(1).max(1e4),
-  reason: z3.string().trim().min(1).max(1e4)
+  expectedOutcome: z4.string().trim().min(1).max(1e4),
+  reason: z4.string().trim().min(1).max(1e4)
 }).strict();
-var RefinerProposalDecisionV2Schema = z3.object({
-  schemaVersion: z3.literal("openpond.localHarnessRefinerDecision.v2"),
-  decision: z3.literal("propose"),
-  route: z3.enum(["memory", "prompt", "skill", "agent"]),
-  operation: z3.enum(["create", "update", "delete"]),
-  target: z3.string().trim().min(1).max(2e3),
-  summary: z3.string().trim().min(1).max(2e3),
+var RefinerProposalDecisionV2Schema = z4.object({
+  schemaVersion: z4.literal("openpond.localHarnessRefinerDecision.v2"),
+  decision: z4.literal("propose"),
+  route: z4.enum(["memory", "prompt", "skill", "agent"]),
+  operation: z4.enum(["create", "update", "delete"]),
+  target: z4.string().trim().min(1).max(2e3),
+  summary: z4.string().trim().min(1).max(2e3),
   evidenceBasis: HarnessRefinerEvidenceBasisSchema,
-  createContent: z3.string().min(1).max(2e4).nullable(),
-  find: z3.string().min(1).max(8e3).nullable(),
-  replace: z3.string().max(8e3).nullable(),
-  expectedOutcome: z3.string().trim().min(1).max(1e4),
-  reason: z3.string().trim().min(1).max(1e4)
+  createContent: z4.string().min(1).max(2e4).nullable(),
+  find: z4.string().min(1).max(8e3).nullable(),
+  replace: z4.string().max(8e3).nullable(),
+  expectedOutcome: z4.string().trim().min(1).max(1e4),
+  reason: z4.string().trim().min(1).max(1e4)
 }).strict().superRefine((decision, context) => {
   if (decision.operation === "create" && (decision.createContent === null || decision.find !== null || decision.replace !== null)) {
     context.addIssue({
@@ -3123,122 +3243,122 @@ var RefinerProposalDecisionV2Schema = z3.object({
     });
   }
 });
-var LocalHarnessRefinerDecisionV2Schema = z3.discriminatedUnion("decision", [
+var LocalHarnessRefinerDecisionV2Schema = z4.discriminatedUnion("decision", [
   RefinerNoActionDecisionV2Schema,
   RefinerExternalRouteDecisionV2Schema,
   RefinerProposalDecisionV2Schema
 ]);
-var LocalHarnessRefinerDecisionAnySchema = z3.union([
+var LocalHarnessRefinerDecisionAnySchema = z4.union([
   LocalHarnessRefinerDecisionV1Schema,
   LocalHarnessRefinerDecisionV2Schema
 ]);
-var HarnessRefinerCapabilitiesSchema = z3.object({
-  memory: z3.boolean(),
-  prompt: z3.boolean(),
-  skill: z3.boolean(),
-  agent: z3.boolean()
+var HarnessRefinerCapabilitiesSchema = z4.object({
+  memory: z4.boolean(),
+  prompt: z4.boolean(),
+  skill: z4.boolean(),
+  agent: z4.boolean()
 }).strict();
-var SourceKindSchema = z3.enum(["memory", "instruction", "skill", "agent"]);
-var RefinerSourceFileSchema = z3.object({
-  path: z3.string().trim().min(1).max(2e3),
+var SourceKindSchema = z4.enum(["memory", "instruction", "skill", "agent"]);
+var RefinerSourceFileSchema = z4.object({
+  path: z4.string().trim().min(1).max(2e3),
   kind: SourceKindSchema,
-  content: z3.string().max(6e4),
-  loaded: z3.boolean()
+  content: z4.string().max(6e4),
+  loaded: z4.boolean()
 }).strict();
-var RefinerSourceCatalogEntrySchema = z3.object({
-  path: z3.string().trim().min(1).max(2e3),
+var RefinerSourceCatalogEntrySchema = z4.object({
+  path: z4.string().trim().min(1).max(2e3),
   kind: SourceKindSchema,
-  loaded: z3.boolean()
+  loaded: z4.boolean()
 }).strict();
-var LocalHarnessRefinerEvidenceSchema = z3.object({
+var LocalHarnessRefinerEvidenceSchema = z4.object({
   capabilities: HarnessRefinerCapabilitiesSchema,
-  trigger: z3.record(z3.string(), z3.unknown()),
-  observations: z3.array(z3.record(z3.string(), z3.unknown())).max(20),
-  admissibleEvidenceIds: z3.array(z3.string().trim().min(1).max(2e3)).max(1e4),
-  reviewPacket: z3.object({
-    currentTurn: z3.object({
-      id: z3.string().trim().min(1).max(2e3),
-      status: z3.string().trim().min(1).max(100).nullable(),
-      error: z3.string().max(2100).nullable(),
-      prompt: z3.string().max(8100).nullable(),
-      assistantOutput: z3.string().max(8100).nullable(),
-      assistantOutputLinkCount: z3.number().int().nonnegative()
+  trigger: z4.record(z4.string(), z4.unknown()),
+  observations: z4.array(z4.record(z4.string(), z4.unknown())).max(20),
+  admissibleEvidenceIds: z4.array(z4.string().trim().min(1).max(2e3)).max(1e4),
+  reviewPacket: z4.object({
+    currentTurn: z4.object({
+      id: z4.string().trim().min(1).max(2e3),
+      status: z4.string().trim().min(1).max(100).nullable(),
+      error: z4.string().max(2100).nullable(),
+      prompt: z4.string().max(8100).nullable(),
+      assistantOutput: z4.string().max(8100).nullable(),
+      assistantOutputLinkCount: z4.number().int().nonnegative()
     }).strict(),
-    priorConversation: z3.array(z3.object({
-      turnId: z3.string().trim().min(1).max(2e3),
-      status: z3.string().trim().min(1).max(100).nullable(),
-      prompt: z3.string().max(3100).nullable(),
-      assistantOutput: z3.string().max(3100).nullable()
+    priorConversation: z4.array(z4.object({
+      turnId: z4.string().trim().min(1).max(2e3),
+      status: z4.string().trim().min(1).max(100).nullable(),
+      prompt: z4.string().max(3100).nullable(),
+      assistantOutput: z4.string().max(3100).nullable()
     }).strict()).max(3),
-    timeline: z3.array(z3.record(z3.string(), z3.unknown())).max(60),
-    artifacts: z3.array(z3.record(z3.string(), z3.unknown())).max(30),
-    artifactDiagnostics: z3.array(z3.record(z3.string(), z3.unknown())).max(20),
-    executionProfile: z3.object({
-      modelRequestCount: z3.number().int().nonnegative(),
-      failedModelRequestCount: z3.number().int().nonnegative(),
-      promptTokens: z3.number().int().nonnegative(),
-      completionTokens: z3.number().int().nonnegative(),
-      totalTokens: z3.number().int().nonnegative(),
-      toolFailureCount: z3.number().int().nonnegative(),
-      retryCount: z3.number().int().nonnegative(),
-      recoveryCount: z3.number().int().nonnegative()
+    timeline: z4.array(z4.record(z4.string(), z4.unknown())).max(60),
+    artifacts: z4.array(z4.record(z4.string(), z4.unknown())).max(30),
+    artifactDiagnostics: z4.array(z4.record(z4.string(), z4.unknown())).max(20),
+    executionProfile: z4.object({
+      modelRequestCount: z4.number().int().nonnegative(),
+      failedModelRequestCount: z4.number().int().nonnegative(),
+      promptTokens: z4.number().int().nonnegative(),
+      completionTokens: z4.number().int().nonnegative(),
+      totalTokens: z4.number().int().nonnegative(),
+      toolFailureCount: z4.number().int().nonnegative(),
+      retryCount: z4.number().int().nonnegative(),
+      recoveryCount: z4.number().int().nonnegative()
     }).strict(),
-    priorIncidents: z3.array(z3.record(z3.string(), z3.unknown())).max(3),
-    truncation: z3.object({
-      timelineEventCount: z3.number().int().nonnegative(),
-      includedTimelineEventCount: z3.number().int().nonnegative(),
-      timelineTruncated: z3.boolean()
+    priorIncidents: z4.array(z4.record(z4.string(), z4.unknown())).max(3),
+    truncation: z4.object({
+      timelineEventCount: z4.number().int().nonnegative(),
+      includedTimelineEventCount: z4.number().int().nonnegative(),
+      timelineTruncated: z4.boolean()
     }).strict()
   }).strict(),
-  runtimeActivation: z3.object({
+  runtimeActivation: z4.object({
     admittedRelease: ImmutableReleaseRefSchema,
     currentRelease: ImmutableReleaseRefSchema,
-    rebasedOntoCurrent: z3.boolean(),
-    admittedSourceFiles: z3.array(RefinerSourceFileSchema).max(100),
-    admittedSourceCatalog: z3.array(RefinerSourceCatalogEntrySchema).max(1e3)
+    rebasedOntoCurrent: z4.boolean(),
+    admittedSourceFiles: z4.array(RefinerSourceFileSchema).max(100),
+    admittedSourceCatalog: z4.array(RefinerSourceCatalogEntrySchema).max(1e3)
   }).strict(),
-  sourceFiles: z3.array(RefinerSourceFileSchema).max(100),
-  sourceCatalog: z3.array(RefinerSourceCatalogEntrySchema).max(1e3),
-  additionalEvidence: z3.unknown().nullable().optional()
+  sourceFiles: z4.array(RefinerSourceFileSchema).max(100),
+  sourceCatalog: z4.array(RefinerSourceCatalogEntrySchema).max(1e3),
+  additionalEvidence: z4.unknown().nullable().optional()
 }).strict();
 var REFINER_CORE_VERSION = "openpond.refinerCore.v2";
-var OverlayRefSchema = z3.object({
-  id: z3.string().trim().min(1).max(240),
-  revision: z3.number().int().nonnegative(),
+var OverlayRefSchema = z4.object({
+  id: z4.string().trim().min(1).max(240),
+  revision: z4.number().int().nonnegative(),
   contentHash: ReleaseHashSchema
 }).strict();
-var HostedHarnessRefinerRequestSchema = z3.object({
-  schemaVersion: z3.literal("openpond.hostedHarnessRefinerRequest.v2"),
-  requestId: z3.string().trim().min(1).max(240),
-  idempotencyKey: z3.string().trim().min(1).max(240),
+var HostedHarnessRefinerRequestSchema = z4.object({
+  schemaVersion: z4.literal("openpond.hostedHarnessRefinerRequest.v2"),
+  requestId: z4.string().trim().min(1).max(240),
+  idempotencyKey: z4.string().trim().min(1).max(240),
   evidenceHash: ReleaseHashSchema,
-  harness: z3.object({
+  harness: z4.object({
     admittedRelease: ImmutableReleaseRefSchema,
     currentRelease: ImmutableReleaseRefSchema,
     overlay: OverlayRefSchema,
-    workspace: z3.object({
-      id: z3.string().trim().min(1).max(240),
-      revision: z3.number().int().nonnegative(),
+    workspace: z4.object({
+      id: z4.string().trim().min(1).max(240),
+      revision: z4.number().int().nonnegative(),
       sourceRevision: ReleaseHashSchema,
-      channelRevision: z3.number().int().nonnegative()
+      channelRevision: z4.number().int().nonnegative()
     }).strict(),
     capabilities: HarnessRefinerCapabilitiesSchema
   }).strict(),
   evidence: LocalHarnessRefinerEvidenceSchema
 }).strict();
-var HostedHarnessRefinerUsageSchema = z3.object({
-  promptTokens: z3.number().int().nonnegative(),
-  completionTokens: z3.number().int().nonnegative(),
-  totalTokens: z3.number().int().nonnegative()
+var HostedHarnessRefinerUsageSchema = z4.object({
+  promptTokens: z4.number().int().nonnegative(),
+  completionTokens: z4.number().int().nonnegative(),
+  totalTokens: z4.number().int().nonnegative()
 }).strict();
-var HostedHarnessRefinerResponseSchema = z3.object({
-  schemaVersion: z3.literal("openpond.hostedHarnessRefinerResponse.v2"),
-  requestId: z3.string().trim().min(1).max(240),
+var HostedHarnessRefinerResponseSchema = z4.object({
+  schemaVersion: z4.literal("openpond.hostedHarnessRefinerResponse.v2"),
+  requestId: z4.string().trim().min(1).max(240),
   evidenceHash: ReleaseHashSchema,
   admittedRelease: ImmutableReleaseRefSchema,
   currentRelease: ImmutableReleaseRefSchema,
   decision: LocalHarnessRefinerDecisionV2Schema,
-  serviceRevision: z3.string().trim().min(1).max(240),
+  serviceRevision: z4.string().trim().min(1).max(240),
   usage: HostedHarnessRefinerUsageSchema
 }).strict();
 
@@ -3257,10 +3377,12 @@ var OpenPondClient = class {
   workflows;
   actions;
   profileActions;
+  learning;
   constructor(options) {
     const apiKey = options.apiKey.trim();
     if (!apiKey) throw new Error("OpenPond API key is required");
     const apiBaseUrl = options.baseUrl?.trim() || "https://api.openpond.ai";
+    this.learning = (scope) => new OpenPondLearningClient({ apiKey, baseUrl: apiBaseUrl, scope });
     this.sandboxes = createOpenPondSandboxClient({
       apiKey,
       baseUrl: apiBaseUrl,
@@ -3284,6 +3406,8 @@ export {
   DEFAULT_REFINER_REVIEW_PROFILE,
   OpenPondApiError,
   OpenPondClient,
+  OpenPondLearningClient,
+  OpenPondLearningError,
   OpenPondProfileActionsClient,
   OpenPondProjectActionsClient,
   OpenPondSandboxClient,