openpond-sdk 0.10.0 → 0.11.2

package/dist/chunk-YCQVVFE5.js

@@ -0,0 +1,37 @@
+import {
+  fetchConnectedJson
+} from "./chunk-T4APHDES.js";
+
+// src/evaluation-coordination-http.ts
+import { z } from "zod";
+var EvaluationCoordinationTransport = class {
+  constructor(access) {
+    this.access = access;
+    const url = new URL(access.baseUrl);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash || !access.apiKey.trim() || !access.actorId.trim() || !access.teamId.trim()) throw new Error("Select the current evaluation owner and HTTP API origin.");
+    this.origin = url.toString().replace(/\/+$/, "");
+  }
+  access;
+  origin;
+  async post(path, request, signal) {
+    const body = JSON.stringify({ teamId: this.access.teamId, projectId: this.access.projectId, request });
+    if (new TextEncoder().encode(body).byteLength > 1048576) throw new Error("The reviewed evaluation command exceeds 1 MiB.");
+    const { response, value } = await fetchConnectedJson(this.access.fetch ?? fetch, `${this.origin}/v1/${path}`, {
+      method: "POST",
+      redirect: "error",
+      headers: { Authorization: `Bearer ${this.access.apiKey}`, "X-OpenPond-Team-Id": this.access.teamId, "Content-Type": "application/json" },
+      body,
+      signal
+    }, (status, code, message) => Object.assign(new Error(message), { status, code }));
+    if (!response.ok) {
+      const error = z.object({ error: z.string().optional(), message: z.string().optional(), code: z.string().optional() }).passthrough().safeParse(value);
+      throw Object.assign(new Error(error.success ? error.data.error ?? error.data.message ?? "Evaluation operation failed." : "Evaluation operation failed."), { status: response.status, code: error.success ? error.data.code : void 0 });
+    }
+    return value;
+  }
+};
+
+export {
+  EvaluationCoordinationTransport
+};
+//# sourceMappingURL=chunk-YCQVVFE5.js.map

package/dist/chunk-YCQVVFE5.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/evaluation-coordination-http.ts"],
+  "sourcesContent": ["import {z} from \"zod\";\nimport {fetchConnectedJson} from \"./connected-evidence-http.js\";\nexport type EvaluationCoordinationAccess={baseUrl:string;apiKey:string;actorId:string;teamId:string;projectId:string|null;fetch?:typeof fetch};\n/** Bounded authenticated transport for the current evaluation owner. There is\n * no retry or operation allocation here; commands retain their reviewed IDs. */\nexport class EvaluationCoordinationTransport {\n  readonly origin:string;\n  constructor(readonly access:EvaluationCoordinationAccess){\n    const url=new URL(access.baseUrl);\n    if(![\"http:\",\"https:\"].includes(url.protocol)||url.username||url.password||url.search||url.hash||!access.apiKey.trim()||!access.actorId.trim()||!access.teamId.trim())throw new Error(\"Select the current evaluation owner and HTTP API origin.\");\n    this.origin=url.toString().replace(/\\/+$/,\"\");\n  }\n  async post(path:\"experiment-evaluation-schedules\"|\"advanced-refiner-evaluations\",request:unknown,signal?:AbortSignal){\n    const body=JSON.stringify({teamId:this.access.teamId,projectId:this.access.projectId,request});\n    if(new TextEncoder().encode(body).byteLength>1_048_576)throw new Error(\"The reviewed evaluation command exceeds 1 MiB.\");\n    const {response,value}=await fetchConnectedJson(this.access.fetch??fetch,`${this.origin}/v1/${path}`,{\n      method:\"POST\",redirect:\"error\",headers:{Authorization:`Bearer ${this.access.apiKey}`,\"X-OpenPond-Team-Id\":this.access.teamId,\"Content-Type\":\"application/json\"},body,signal,\n    },(status,code,message)=>Object.assign(new Error(message),{status,code}));\n    if(!response.ok){const error=z.object({error:z.string().optional(),message:z.string().optional(),code:z.string().optional()}).passthrough().safeParse(value);throw Object.assign(new Error(error.success?error.data.error??error.data.message??\"Evaluation operation failed.\":\"Evaluation operation failed.\"),{status:response.status,code:error.success?error.data.code:undefined});}\n    return value;\n  }\n}\n"],
+  "mappings": ";;;;;AAAA,SAAQ,SAAQ;AAKT,IAAM,kCAAN,MAAsC;AAAA,EAE3C,YAAqB,QAAoC;AAApC;AACnB,UAAM,MAAI,IAAI,IAAI,OAAO,OAAO;AAChC,QAAG,CAAC,CAAC,SAAQ,QAAQ,EAAE,SAAS,IAAI,QAAQ,KAAG,IAAI,YAAU,IAAI,YAAU,IAAI,UAAQ,IAAI,QAAM,CAAC,OAAO,OAAO,KAAK,KAAG,CAAC,OAAO,QAAQ,KAAK,KAAG,CAAC,OAAO,OAAO,KAAK,EAAE,OAAM,IAAI,MAAM,0DAA0D;AAChP,SAAK,SAAO,IAAI,SAAS,EAAE,QAAQ,QAAO,EAAE;AAAA,EAC9C;AAAA,EAJqB;AAAA,EADZ;AAAA,EAMT,MAAM,KAAK,MAAsE,SAAgB,QAAoB;AACnH,UAAM,OAAK,KAAK,UAAU,EAAC,QAAO,KAAK,OAAO,QAAO,WAAU,KAAK,OAAO,WAAU,QAAO,CAAC;AAC7F,QAAG,IAAI,YAAY,EAAE,OAAO,IAAI,EAAE,aAAW,QAAU,OAAM,IAAI,MAAM,gDAAgD;AACvH,UAAM,EAAC,UAAS,MAAK,IAAE,MAAM,mBAAmB,KAAK,OAAO,SAAO,OAAM,GAAG,KAAK,MAAM,OAAO,IAAI,IAAG;AAAA,MACnG,QAAO;AAAA,MAAO,UAAS;AAAA,MAAQ,SAAQ,EAAC,eAAc,UAAU,KAAK,OAAO,MAAM,IAAG,sBAAqB,KAAK,OAAO,QAAO,gBAAe,mBAAkB;AAAA,MAAE;AAAA,MAAK;AAAA,IACvK,GAAE,CAAC,QAAO,MAAK,YAAU,OAAO,OAAO,IAAI,MAAM,OAAO,GAAE,EAAC,QAAO,KAAI,CAAC,CAAC;AACxE,QAAG,CAAC,SAAS,IAAG;AAAC,YAAM,QAAM,EAAE,OAAO,EAAC,OAAM,EAAE,OAAO,EAAE,SAAS,GAAE,SAAQ,EAAE,OAAO,EAAE,SAAS,GAAE,MAAK,EAAE,OAAO,EAAE,SAAS,EAAC,CAAC,EAAE,YAAY,EAAE,UAAU,KAAK;AAAE,YAAM,OAAO,OAAO,IAAI,MAAM,MAAM,UAAQ,MAAM,KAAK,SAAO,MAAM,KAAK,WAAS,iCAA+B,8BAA8B,GAAE,EAAC,QAAO,SAAS,QAAO,MAAK,MAAM,UAAQ,MAAM,KAAK,OAAK,OAAS,CAAC;AAAA,IAAE;AACrX,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

package/dist/chunk-YTGRET2L.js

@@ -0,0 +1,604 @@
+import {
+  DatasetWorkspaceReceiptSchema
+} from "./chunk-HKAR3VPB.js";
+import {
+  fetchConnectedJson
+} from "./chunk-T4APHDES.js";
+import {
+  ImmutableReleaseRefSchema,
+  contentHash
+} from "./chunk-QUOW6URQ.js";
+
+// src/connected-evidence-contracts.ts
+import { z } from "zod";
+import { ConnectedSourceKindSchema, ConnectedBoundarySchema, ConnectedUsageSummarySchema, CONNECTED_EVIDENCE_LIMITS } from "@openpond/evals/connected-evidence";
+var Id = z.string().trim().min(1).max(500);
+var Hash = z.string().regex(/^[a-f0-9]{64}$/);
+var ConnectedScopeSchema = z.object({ teamId: Id, ownerUserId: Id }).strict();
+var ConnectedCaseRefSchema = z.object({ id: Id, snapshotHash: Hash, boundaryId: Id, boundaryRevisionHash: Hash }).strict();
+var ConnectedSourceSummarySchema = z.object({
+  sourceId: Id,
+  source: ConnectedSourceKindSchema,
+  sessionId: Id,
+  snapshotHash: Hash,
+  title: z.string().max(500),
+  projectId: Id.nullable(),
+  capturedAt: z.string().datetime(),
+  boundaries: z.array(ConnectedBoundarySchema.omit({ start: true, end: true })).max(CONNECTED_EVIDENCE_LIMITS.boundaries)
+}).strict();
+var ConnectedCaptureRequestSchema = z.object({
+  operationId: Id,
+  conversationId: Id.optional(),
+  cursor: Id.optional(),
+  limit: z.number().int().min(1).max(50).default(20)
+}).strict();
+var AgentImportUploadRefSchema = z.object({ hash: Hash, parts: z.number().int().min(1).max(1500) }).strict();
+var AgentImportUploadPartSchema = AgentImportUploadRefSchema.extend({ index: z.number().int().nonnegative().max(1499), base64: z.string().max(35e4) }).strict();
+var AgentImportFileSchema = z.object({ path: z.string().min(1).max(500), encoding: z.enum(["utf8", "zstd"]), base64: z.string() }).strict();
+var AgentImportPreviewRequestSchema = z.object({
+  upload: AgentImportUploadRefSchema,
+  source: z.enum(["codex", "claude_code", "hermes", "openclaw", "opencode", "grok_build", "pi", "oh_my_pi"]),
+  branchLeafId: Id.optional(),
+  acquisition: z.object({ machineId: Id, sourceInstanceId: Id }).strict().optional(),
+  destination: z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("existing"), projectId: Id }).strict(),
+    z.object({ kind: z.literal("new"), name: z.string().trim().min(1).max(200) }).strict()
+  ])
+}).strict();
+var AgentImportCommitRequestSchema = AgentImportPreviewRequestSchema.extend({
+  operationId: Id,
+  previewHash: Hash,
+  selection: z.array(z.object({ sessionHash: Hash, boundaryIds: z.array(Id).min(1).max(CONNECTED_EVIDENCE_LIMITS.boundaries) }).strict()).min(1).max(CONNECTED_EVIDENCE_LIMITS.sessions)
+}).strict();
+var ConnectedHomeQuerySchema = z.object({ from: z.string().datetime(), to: z.string().datetime(), projectId: Id.optional() }).strict();
+var ConnectedHomeSummarySchema = z.object({
+  teamId: Id,
+  range: ConnectedHomeQuerySchema,
+  activity: z.object({ conversations: z.number().int().nonnegative(), turns: z.number().int().nonnegative(), chatTurns: z.number().int().nonnegative(), workTurns: z.number().int().nonnegative() }).strict(),
+  accounting: z.object({ contextSnapshots: z.number().int().nonnegative() }).strict(),
+  usage: ConnectedUsageSummarySchema
+}).strict();
+
+// src/connected-recorded-execution.ts
+import { z as z2 } from "zod";
+import { ExperimentManifestSchema } from "@openpond/evals/experiments";
+import { TaskRecordSchema } from "@openpond/evals/tasksets";
+var Id2 = z2.string().min(1).max(200);
+var Hash2 = z2.string().regex(/^[a-f0-9]{64}$/);
+var ConnectedRecordedExecutionRequestSchema = z2.object({
+  operationId: Id2,
+  name: z2.string().trim().min(1).max(500),
+  projectId: Id2,
+  dataset: ImmutableReleaseRefSchema.extend({ revision: z2.number().int().positive() }).strict(),
+  caseIds: z2.array(Id2).min(1).max(1e4)
+}).strict().superRefine((value, ctx) => {
+  if (new Set(value.caseIds).size !== value.caseIds.length) ctx.addIssue({ code: "custom", message: "Select each case once." });
+});
+var ConnectedRecordedSourceSchema = ConnectedCaseRefSchema.extend({
+  inputHash: Hash2,
+  outputHash: Hash2.nullable(),
+  task: TaskRecordSchema,
+  taskHash: Hash2
+}).strict();
+var ConnectedRecordedExecutionSchema = z2.object({
+  schemaVersion: z2.literal("openpond.connectedRecordedExecution.v1"),
+  id: Id2,
+  teamId: Id2,
+  ownerUserId: Id2,
+  request: ConnectedRecordedExecutionRequestSchema,
+  manifest: ExperimentManifestSchema,
+  sources: z2.array(ConnectedRecordedSourceSchema).min(1).max(1e4),
+  contentHash: Hash2
+}).strict();
+function verifyConnectedRecordedExecution(raw) {
+  const value = ConnectedRecordedExecutionSchema.parse(raw), { contentHash: actual, ...body } = value;
+  const { contentHash: manifestHash, ...manifest } = value.manifest;
+  if (contentHash(body) !== actual || contentHash(manifest) !== manifestHash || value.manifest.teamId !== value.teamId || value.manifest.id !== value.id || value.manifest.operationId !== value.request.operationId || contentHash(value.manifest.dataset) !== contentHash(value.request.dataset) || value.sources.length !== value.request.caseIds.length || value.sources.length !== value.manifest.population.length || value.sources.some((source, index) => source.taskHash !== contentHash(source.task) || source.task.id !== value.request.caseIds[index] || source.boundaryId !== source.task.id || value.manifest.population[index]?.caseId !== source.boundaryId))
+    throw new Error("Recorded execution identity or population integrity failed.");
+  return value;
+}
+var ConnectedRecordedListRequestSchema = z2.object({ projectId: Id2.optional(), cursor: Id2.optional(), limit: z2.number().int().min(1).max(50).default(20) }).strict();
+var ConnectedRecordedSummarySchema = z2.object({
+  id: Id2,
+  teamId: Id2,
+  ownerUserId: Id2,
+  projectId: Id2,
+  name: z2.string().min(1).max(500),
+  dataset: ConnectedRecordedExecutionRequestSchema.shape.dataset,
+  manifestHash: Hash2,
+  contentHash: Hash2,
+  caseCount: z2.number().int().min(1).max(1e4),
+  createdAt: z2.string().datetime()
+}).strict();
+var ConnectedRecordedListSchema = z2.object({ teamId: Id2, items: z2.array(ConnectedRecordedSummarySchema).max(50), nextCursor: Id2.nullable() }).strict();
+
+// src/connected-evidence-client.ts
+import { z as z5 } from "zod";
+import { ConnectedBoundarySchema as ConnectedBoundarySchema2, ConnectedEventSchema, ConnectedUsageSummarySchema as ConnectedUsageSummarySchema2 } from "@openpond/evals/connected-evidence";
+
+// src/connected-dataset-publication.ts
+import { z as z3 } from "zod";
+import { RewardReleaseRefSchema } from "@openpond/evals/rewards";
+var ConnectedDatasetPublicationSchema = z3.object({
+  datasetId: z3.string().trim().min(1).max(240),
+  expectedRevision: z3.number().int().positive(),
+  operationId: z3.string().trim().min(1).max(240),
+  graders: z3.array(RewardReleaseRefSchema).min(1).max(100).optional()
+}).strict().superRefine((request, context) => {
+  if (request.graders && new Set(request.graders.map((ref) => ref.id)).size !== request.graders.length)
+    context.addIssue({ code: "custom", path: ["graders"], message: "Choose one exact revision of each grader." });
+});
+
+// src/connected-collection-status.ts
+import { z as z4 } from "zod";
+var Id3 = z4.string().min(1).max(500);
+var Count = z4.number().int().nonnegative();
+var ConnectedCollectionStatusSchema = z4.object({
+  teamId: Id3,
+  ownerUserId: Id3,
+  projectId: Id3.nullable(),
+  status: z4.enum(["active", "paused", "archived"]),
+  revision: Count,
+  state: z4.enum(["collecting", "pending", "attention", "paused", "archived"]),
+  lastReconciledAt: z4.string().datetime().nullable(),
+  lastCapturedAt: z4.string().datetime().nullable(),
+  historyDays: z4.number().int().positive(),
+  sources: Count,
+  tasks: Count,
+  datasets: z4.array(z4.object({
+    datasetId: Id3,
+    projection: z4.enum(["turn", "conversation"]),
+    revision: Count
+  }).strict()).max(2),
+  latestBatch: z4.object({
+    operationId: Id3,
+    updatedAt: z4.string().datetime(),
+    scanned: Count,
+    captured: Count,
+    unchanged: Count,
+    pending: Count,
+    failed: Count,
+    excluded: Count,
+    paused: Count,
+    hasMore: z4.boolean()
+  }).strict().nullable()
+}).strict();
+
+// src/connected-evidence-client.ts
+var Id4 = z5.string().min(1).max(500);
+var Hash3 = z5.string().regex(/^[a-f0-9]{64}$/);
+var ConnectedCollectionSchema = z5.object({ teamId: Id4, projectId: Id4.nullable(), status: z5.enum(["active", "paused", "archived"]), revision: z5.number().int().nonnegative() }).strict();
+var ConnectedCaptureReceiptSchema = z5.object({
+  teamId: Id4,
+  operationId: Id4,
+  projectId: Id4.nullable(),
+  outcomes: z5.array(z5.object({
+    conversationId: Id4,
+    state: z5.enum(["captured", "unchanged", "pending", "paused", "excluded", "failed"]),
+    sourceId: Id4.optional(),
+    snapshotHash: Hash3.optional(),
+    reason: z5.string().optional()
+  }).strict()).max(50),
+  nextCursor: Id4.nullable()
+}).strict();
+var ConnectedCaseReadbackSchema = z5.object({
+  teamId: Id4,
+  ref: ConnectedCaseRefSchema,
+  origin: ConnectedSourceSummarySchema.shape.source,
+  sessionId: Id4,
+  projectId: Id4,
+  capturedAt: z5.string().datetime(),
+  unmappedEvidence: z5.object({ count: z5.number().int().nonnegative().max(1e5), contentHash: Hash3 }).strict(),
+  evidence: z5.object({ input: z5.array(ConnectedEventSchema), observed: z5.array(ConnectedEventSchema), answer: z5.json(), boundary: ConnectedBoundarySchema2 }).strict()
+}).strict();
+var ConnectedUnmappedEventsSchema = z5.object({
+  teamId: Id4,
+  sourceId: Id4,
+  snapshotHash: Hash3,
+  contentHash: Hash3,
+  count: z5.number().int().nonnegative(),
+  offset: z5.number().int().nonnegative(),
+  events: z5.array(ConnectedEventSchema).max(50),
+  nextOffset: z5.number().int().nonnegative().nullable()
+}).strict();
+var AgentImportPreviewSchema = z5.object({
+  teamId: Id4,
+  source: AgentImportPreviewRequestSchema.shape.source,
+  sourceHash: Hash3,
+  previewHash: Hash3,
+  destination: AgentImportPreviewRequestSchema.shape.destination,
+  issues: z5.array(z5.object({ file: z5.string(), message: z5.string() }).strict()).max(100),
+  sessions: z5.array(z5.object({
+    sessionHash: Hash3,
+    sessionId: Id4,
+    origin: ConnectedSourceSummarySchema.shape.source,
+    exporterVersion: z5.string().nullable(),
+    eventCount: z5.number().int().nonnegative(),
+    boundaries: z5.array(z5.object({
+      id: Id4,
+      projection: z5.enum(["turn", "conversation"]),
+      answer: z5.boolean(),
+      process: z5.enum(["retained", "partial", "absent"]),
+      terminal: z5.enum(["completed", "failed", "cancelled", "unknown"])
+    }).strict()).max(5001),
+    warnings: z5.array(z5.string()).max(100),
+    sample: z5.array(z5.object({ role: z5.enum(["user", "assistant", "system", "tool"]).nullable(), text: z5.string().max(4e3) }).strict()).max(3)
+  }).strict()).max(1e3)
+}).strict();
+var AgentImportReceiptSchema = z5.object({
+  teamId: Id4,
+  operationId: Id4,
+  requestHash: Hash3,
+  previewHash: Hash3,
+  projectId: Id4.optional(),
+  state: z5.enum(["admitting", "publishing", "completed", "failed"]),
+  outcomes: z5.array(z5.object({
+    sessionHash: Hash3,
+    sourceId: Id4,
+    status: z5.enum(["imported", "already_present"]),
+    datasets: z5.array(z5.object({ datasetId: Id4, revision: z5.number().int().positive(), changed: z5.boolean() }).strict()).max(2)
+  }).strict()).max(1e3),
+  error: z5.string().optional()
+}).strict();
+var ConnectedEvidenceError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "ConnectedEvidenceError";
+  }
+  status;
+  code;
+};
+var ConnectedEvidenceClient = class {
+  constructor(options) {
+    this.options = options;
+    const url = new URL(options.baseUrl);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash || !options.apiKey.trim() || !options.teamId.trim())
+      throw new Error("A clean API origin and workspace credentials are required.");
+    this.baseUrl = url.toString().replace(/\/+$/, "");
+  }
+  options;
+  baseUrl;
+  async capture(raw, signal) {
+    const request = ConnectedCaptureRequestSchema.parse(raw), result = ConnectedCaptureReceiptSchema.parse(await this.request("/capture", "POST", request, signal));
+    this.scope(result.teamId);
+    if (result.operationId !== request.operationId || result.outcomes.length > request.limit || request.conversationId && result.outcomes.some((item) => item.conversationId !== request.conversationId))
+      throw new Error("Capture receipt differs from its requested source or operation.");
+    return result;
+  }
+  async list(input = {}, signal) {
+    const query = z5.object({ projectId: Id4.optional(), cursor: Id4.optional(), limit: z5.number().int().min(1).max(50).default(20) }).strict().parse(input);
+    const params = new URLSearchParams(Object.entries(query).filter(([, value]) => value !== void 0).map(([key, value]) => [key, String(value)]));
+    const page = z5.object({ teamId: Id4, items: z5.array(ConnectedSourceSummarySchema).max(50), nextCursor: Id4.nullable() }).strict().parse(await this.request(`?${params}`, "GET", void 0, signal));
+    this.scope(page.teamId);
+    if (page.items.length > query.limit || new Set(page.items.map((item) => item.sourceId)).size !== page.items.length || page.nextCursor !== null && page.nextCursor === query.cursor || query.projectId && page.items.some((item) => item.projectId !== query.projectId)) throw new Error("Connected source page differs from its requested scope.");
+    return page;
+  }
+  async read(raw, signal) {
+    const ref = ConnectedCaseRefSchema.parse(raw);
+    const result = ConnectedCaseReadbackSchema.parse(await this.request(`/${encodeURIComponent(ref.id)}/cases/${encodeURIComponent(ref.boundaryId)}?snapshotHash=${ref.snapshotHash}&revisionHash=${ref.boundaryRevisionHash}`, "GET", void 0, signal));
+    this.scope(result.teamId);
+    if (contentHash(result.ref) !== contentHash(ref) || result.evidence.boundary.id !== ref.boundaryId || result.evidence.boundary.revisionHash !== ref.boundaryRevisionHash || contentHash(result.evidence.input) !== result.evidence.boundary.inputHash || contentHash(result.evidence.observed) !== ref.boundaryRevisionHash || result.evidence.boundary.outputHash !== null && contentHash(result.evidence.answer) !== result.evidence.boundary.outputHash)
+      throw new Error("Connected case readback differs from its exact snapshot or cutoff.");
+    return result;
+  }
+  async setCollection(paused, signal) {
+    const result = ConnectedCollectionSchema.parse(await this.request("/collection", "PUT", z5.object({ paused: z5.boolean() }).strict().parse({ paused }), signal));
+    this.scope(result.teamId);
+    return result;
+  }
+  async collection(signal) {
+    const result = ConnectedCollectionSchema.parse(await this.request("/collection", "GET", void 0, signal));
+    this.scope(result.teamId);
+    return result;
+  }
+  async collectionStatus(signal) {
+    const result = ConnectedCollectionStatusSchema.parse(await this.request("/collection/status", "GET", void 0, signal));
+    this.scope(result.teamId);
+    return result;
+  }
+  async unmappedEvents(input, signal) {
+    const request = z5.object({ id: Id4, snapshotHash: Hash3, contentHash: Hash3, offset: z5.number().int().nonnegative().default(0), limit: z5.number().int().min(1).max(50).default(20) }).strict().parse(input);
+    const result = ConnectedUnmappedEventsSchema.parse(await this.request(`/${encodeURIComponent(request.id)}/unmapped-events?snapshotHash=${request.snapshotHash}&offset=${request.offset}&limit=${request.limit}`, "GET", void 0, signal));
+    this.scope(result.teamId);
+    if (result.sourceId !== request.id || result.snapshotHash !== request.snapshotHash || result.contentHash !== request.contentHash || result.offset !== request.offset || result.events.length > request.limit || result.events.some((event, index) => event.sequence !== request.offset + index) || result.nextOffset !== null && result.nextOffset !== request.offset + result.events.length) throw new Error("Unmapped source event page differs from its pinned snapshot.");
+    return result;
+  }
+  async homeSummary(raw, signal) {
+    const querySchema = z5.object({ from: z5.string().datetime(), to: z5.string().datetime(), projectId: Id4.optional() }).strict(), query = querySchema.parse(raw);
+    const params = new URLSearchParams(Object.entries(query));
+    const result = z5.object({ teamId: Id4, range: querySchema, activity: z5.object({
+      conversations: z5.number().int().nonnegative(),
+      turns: z5.number().int().nonnegative(),
+      chatTurns: z5.number().int().nonnegative(),
+      workTurns: z5.number().int().nonnegative()
+    }).strict(), accounting: z5.object({ contextSnapshots: z5.number().int().nonnegative() }).strict(), usage: ConnectedUsageSummarySchema2 }).strict().parse(await this.request(`/summary?${params}`, "GET", void 0, signal));
+    this.scope(result.teamId);
+    if (contentHash(result.range) !== contentHash(query) || result.activity.chatTurns + result.activity.workTurns !== result.activity.turns) throw new Error("Activity summary differs from its requested range.");
+    for (const groups of [result.usage.days, result.usage.modes, result.usage.models]) {
+      if (new Set(groups.map((row) => row.key)).size !== groups.length) throw new Error("Duplicate usage summary group.");
+      for (const key of Object.keys(result.usage.total))
+        if (groups.reduce((sum, row) => sum + row[key], 0) !== result.usage.total[key]) throw new Error("Usage totals differ from their displayed groups.");
+    }
+    return result;
+  }
+  async uploadPart(raw, signal) {
+    const body = AgentImportUploadPartSchema.parse(raw), result = z5.object({ teamId: Id4, hash: Hash3, parts: z5.number().int(), index: z5.number().int() }).strict().parse(await this.request("/imports/upload", "POST", body, signal));
+    this.scope(result.teamId);
+    if (result.hash !== body.hash || result.parts !== body.parts || result.index !== body.index) throw new Error("Upload receipt differs from its part identity.");
+    return result;
+  }
+  async preview(raw, signal) {
+    const request = AgentImportPreviewRequestSchema.parse(raw), result = AgentImportPreviewSchema.parse(await this.request("/imports/preview", "POST", request, signal));
+    this.scope(result.teamId);
+    if (result.source !== request.source || contentHash(result.destination) !== contentHash(request.destination) || result.sessions.some((session) => session.origin !== request.source) || new Set(result.sessions.map((session) => session.sessionHash)).size !== result.sessions.length) throw new Error("Import preview differs from its source or destination.");
+    return result;
+  }
+  async commit(raw, signal) {
+    const request = AgentImportCommitRequestSchema.parse(raw), result = AgentImportReceiptSchema.parse(await this.request("/imports/commit", "POST", request, signal));
+    this.scope(result.teamId);
+    if (result.operationId !== request.operationId || result.previewHash !== request.previewHash || result.requestHash !== contentHash(request) || result.outcomes.some((item) => !request.selection.some((selection) => selection.sessionHash === item.sessionHash)) || result.state === "completed" && result.outcomes.length !== request.selection.length) throw new Error("Import receipt differs from its exact selection or operation.");
+    return result;
+  }
+  async readImport(operationId, signal) {
+    const id = Id4.parse(operationId), result = AgentImportReceiptSchema.parse(await this.request(`/imports/${encodeURIComponent(id)}`, "GET", void 0, signal));
+    this.scope(result.teamId);
+    if (result.operationId !== id) throw new Error("Import identity mismatch.");
+    return result;
+  }
+  async prepareRecorded(raw, signal) {
+    const request = ConnectedRecordedExecutionRequestSchema.parse(raw), result = verifyConnectedRecordedExecution(await this.request("/recorded-executions", "POST", request, signal));
+    this.scope(result.teamId);
+    if (contentHash(result.request) !== contentHash(request)) throw new Error("Recorded admission differs from its selected Dataset/cases.");
+    return result;
+  }
+  async listRecordedExecutions(input = {}, signal) {
+    const query = ConnectedRecordedListRequestSchema.parse(input);
+    const params = new URLSearchParams(Object.entries(query).filter(([, value]) => value !== void 0).map(([key, value]) => [key, String(value)]));
+    const page = ConnectedRecordedListSchema.parse(await this.request(`/recorded-executions?${params}`, "GET", void 0, signal));
+    this.scope(page.teamId);
+    if (page.items.length > query.limit || page.items.some((row, index) => row.teamId !== page.teamId || query.projectId && row.projectId !== query.projectId || query.cursor && row.id <= query.cursor || index > 0 && row.id <= page.items[index - 1].id) || page.items.some((row) => row.ownerUserId !== page.items[0]?.ownerUserId) || page.nextCursor !== null && (query.cursor !== void 0 && page.nextCursor <= query.cursor || page.items.length > 0 && page.nextCursor < page.items.at(-1).id))
+      throw new Error("Recorded execution page differs from its requested scope or cursor.");
+    return page;
+  }
+  async recordedExecution(id, signal) {
+    const result = verifyConnectedRecordedExecution(await this.request(`/recorded-executions/${encodeURIComponent(Id4.parse(id))}`, "GET", void 0, signal));
+    this.scope(result.teamId);
+    if (result.id !== id) throw new Error("Recorded execution identity mismatch.");
+    return result;
+  }
+  async publishDataset(input, signal) {
+    const request = ConnectedDatasetPublicationSchema.parse(input);
+    const result = DatasetWorkspaceReceiptSchema.parse(await this.request("/datasets/publish", "POST", request, signal));
+    this.scope(result.teamId);
+    const frozen = result.workspace.draft.metadata.connectedPublication;
+    if (result.datasetId !== request.datasetId || !result.publication || !frozen || typeof frozen !== "object" || !("requestHash" in frozen) || frozen.requestHash !== contentHash(request)) throw new Error("Published Dataset identity or original selection mismatch.");
+    return result;
+  }
+  async createSelection(input, signal) {
+    const request = z5.object({ operationId: Id4.max(240), projectId: Id4.max(240), name: z5.string().trim().min(1).max(200), cases: z5.array(ConnectedCaseRefSchema).min(1).max(500) }).strict().parse(input);
+    const result = DatasetWorkspaceReceiptSchema.parse(await this.request("/datasets/selection", "POST", request, signal));
+    this.scope(result.teamId);
+    if (result.originProjectId !== request.projectId || result.workspace.draft.tasks.length !== request.cases.length || result.workspace.draft.tasks.some((task, index) => contentHash(task.input && typeof task.input === "object" && !Array.isArray(task.input) ? task.input.connectedEvidenceRef : null) !== contentHash(request.cases[index])))
+      throw new Error("Selected Dataset differs from its exact source population.");
+    return result;
+  }
+  scope(teamId) {
+    if (teamId !== this.options.teamId) throw new Error("Connected evidence workspace mismatch.");
+  }
+  async request(path, method, body, signal) {
+    const { response, value } = await fetchConnectedJson(this.options.fetch ?? fetch, `${this.baseUrl}/v1/connected-evidence${path}`, {
+      method,
+      signal,
+      redirect: "error",
+      headers: { Authorization: `Bearer ${this.options.apiKey}`, "X-OpenPond-Team-Id": this.options.teamId, "Content-Type": "application/json", Accept: "application/json" },
+      ...body === void 0 ? {} : { body: JSON.stringify(body) }
+    }, (status, code, message) => new ConnectedEvidenceError(status, code, message));
+    if (!response.ok) {
+      const error = z5.object({ code: z5.string(), message: z5.string() }).safeParse(value);
+      throw new ConnectedEvidenceError(response.status, error.success ? error.data.code : "connected_request_failed", error.success ? error.data.message : "Connected evidence request failed.");
+    }
+    return value;
+  }
+};
+
+// src/connected-sync.ts
+import { z as z6 } from "zod";
+var Id5 = z6.string().trim().min(1).max(240);
+var ConnectedSyncRegistrationSchema = z6.object({
+  id: Id5,
+  source: AgentImportPreviewRequestSchema.shape.source,
+  machineId: Id5,
+  sourceInstanceId: Id5,
+  sourceLabel: z6.string().trim().min(1).max(200),
+  sourceRoot: z6.string().min(1).max(2e3),
+  destination: AgentImportPreviewRequestSchema.shape.destination,
+  since: z6.string().datetime().nullable(),
+  keepSyncing: z6.boolean(),
+  expectedRevision: z6.number().int().nonnegative()
+}).strict();
+var ConnectedSyncControlSchema = z6.object({
+  id: Id5,
+  expectedRevision: z6.number().int().positive(),
+  action: z6.enum(["pause", "resume", "disconnect"])
+}).strict();
+var ConnectedSyncRequestSchema = z6.object({
+  id: Id5,
+  operationId: Id5,
+  expectedRevision: z6.number().int().positive()
+}).strict();
+var ConnectedSyncHeartbeatSchema = z6.object({
+  id: Id5,
+  expectedRevision: z6.number().int().positive(),
+  pendingOperations: z6.number().int().min(0).max(1e4),
+  error: z6.string().max(500).nullable(),
+  completedSyncRevision: z6.number().int().nonnegative().default(0)
+}).strict();
+var ConnectedSyncConnectionSchema = z6.object({
+  teamId: Id5,
+  id: Id5,
+  revision: z6.number().int().positive(),
+  source: AgentImportPreviewRequestSchema.shape.source,
+  sourceLabel: z6.string(),
+  sourceRoot: z6.string(),
+  taskDatasetId: Id5.nullable(),
+  conversationDatasetId: Id5.nullable(),
+  machineId: Id5,
+  sourceInstanceId: Id5,
+  projectId: Id5,
+  datasetIds: z6.array(Id5).max(2),
+  since: z6.string().datetime().nullable(),
+  keepSyncing: z6.boolean(),
+  state: z6.enum(["active", "paused", "disconnected"]),
+  health: z6.enum(["online", "offline"]),
+  lastHeartbeatAt: z6.string().datetime().nullable(),
+  lastAdmissionAt: z6.string().datetime().nullable(),
+  pendingOperations: z6.number().int().nonnegative(),
+  admittedTasks: z6.number().int().nonnegative(),
+  error: z6.string().nullable(),
+  requestedSyncRevision: z6.number().int().nonnegative().default(0),
+  completedSyncRevision: z6.number().int().nonnegative().default(0),
+  syncRequestedAt: z6.string().datetime().nullable().default(null),
+  syncCompletedAt: z6.string().datetime().nullable().default(null)
+}).strict().refine((value) => value.completedSyncRevision <= value.requestedSyncRevision && value.requestedSyncRevision <= value.revision, "Invalid sync acknowledgement generation.");
+var ConnectedSyncCommitSchema = z6.object({
+  connectionId: Id5,
+  expectedRevision: z6.number().int().positive(),
+  request: AgentImportCommitRequestSchema
+}).strict();
+var ConnectedSyncClient = class {
+  constructor(options) {
+    this.options = options;
+    const url = new URL(options.baseUrl);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+      throw new Error("Invalid connected-sync API origin.");
+  }
+  options;
+  async list(signal) {
+    const result = z6.object({
+      teamId: Id5,
+      items: z6.array(ConnectedSyncConnectionSchema).max(100)
+    }).strict().parse(await this.request("", "GET", void 0, signal));
+    if (result.teamId !== this.options.teamId || result.items.some((item) => item.teamId !== result.teamId))
+      throw new Error("Sync workspace mismatch.");
+    return result;
+  }
+  async register(raw, signal) {
+    return this.connection(
+      await this.request(
+        "",
+        "POST",
+        ConnectedSyncRegistrationSchema.parse(raw),
+        signal
+      ),
+      raw.id
+    );
+  }
+  async control(raw, signal) {
+    return this.connection(
+      await this.request(
+        "/control",
+        "POST",
+        ConnectedSyncControlSchema.parse(raw),
+        signal
+      ),
+      raw.id
+    );
+  }
+  async heartbeat(raw, signal) {
+    return this.connection(
+      await this.request(
+        "/heartbeat",
+        "POST",
+        ConnectedSyncHeartbeatSchema.parse(raw),
+        signal
+      ),
+      raw.id
+    );
+  }
+  async requestSync(raw, signal) {
+    return this.connection(
+      await this.request("/sync-now", "POST", ConnectedSyncRequestSchema.parse(raw), signal),
+      raw.id
+    );
+  }
+  async commit(raw, signal) {
+    return this.request(
+      "/commit",
+      "POST",
+      ConnectedSyncCommitSchema.parse(raw),
+      signal
+    );
+  }
+  connection(raw, id) {
+    const result = ConnectedSyncConnectionSchema.parse(raw);
+    if (result.teamId !== this.options.teamId || result.id !== id)
+      throw new Error("Sync connection identity mismatch.");
+    return result;
+  }
+  async request(path, method, body, signal) {
+    const { response, value } = await fetchConnectedJson(
+      this.options.fetch ?? fetch,
+      `${this.options.baseUrl.replace(/\/+$/u, "")}/v1/connected-evidence/sync/connections${path}`,
+      {
+        method,
+        signal,
+        redirect: "error",
+        headers: {
+          Authorization: `Bearer ${this.options.apiKey}`,
+          "X-OpenPond-Team-Id": this.options.teamId,
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        ...body === void 0 ? {} : { body: JSON.stringify(body) }
+      },
+      (_status, _code, message) => new Error(message)
+    );
+    if (!response.ok)
+      throw Object.assign(
+        new Error(`Sync request failed (${response.status}).`),
+        { status: response.status }
+      );
+    return value;
+  }
+};
+
+export {
+  ConnectedScopeSchema,
+  ConnectedCaseRefSchema,
+  ConnectedSourceSummarySchema,
+  ConnectedCaptureRequestSchema,
+  AgentImportUploadRefSchema,
+  AgentImportUploadPartSchema,
+  AgentImportFileSchema,
+  AgentImportPreviewRequestSchema,
+  AgentImportCommitRequestSchema,
+  ConnectedHomeQuerySchema,
+  ConnectedHomeSummarySchema,
+  ConnectedRecordedExecutionRequestSchema,
+  ConnectedRecordedSourceSchema,
+  ConnectedRecordedExecutionSchema,
+  verifyConnectedRecordedExecution,
+  ConnectedRecordedListRequestSchema,
+  ConnectedRecordedSummarySchema,
+  ConnectedRecordedListSchema,
+  ConnectedDatasetPublicationSchema,
+  ConnectedCollectionStatusSchema,
+  ConnectedCollectionSchema,
+  ConnectedCaptureReceiptSchema,
+  ConnectedCaseReadbackSchema,
+  ConnectedUnmappedEventsSchema,
+  AgentImportPreviewSchema,
+  AgentImportReceiptSchema,
+  ConnectedEvidenceError,
+  ConnectedEvidenceClient,
+  ConnectedSyncRegistrationSchema,
+  ConnectedSyncControlSchema,
+  ConnectedSyncRequestSchema,
+  ConnectedSyncHeartbeatSchema,
+  ConnectedSyncConnectionSchema,
+  ConnectedSyncCommitSchema,
+  ConnectedSyncClient
+};
+//# sourceMappingURL=chunk-YTGRET2L.js.map