@runtypelabs/sdk 5.9.0 → 6.1.3

package/dist/index.mjs

@@ -1151,6 +1151,7 @@ var FlowBuilder = class {
         markdownIfAvailable: config.markdownIfAvailable,
         fetchMethod: config.fetchMethod === "http" ? "standard" : config.fetchMethod,
         firecrawl: config.firecrawl,
+        massive: config.massive,
         outputVariable: config.outputVariable,
         errorHandling: config.errorHandling,
         defaultValue: config.defaultValue,
@@ -1286,7 +1287,10 @@ var FlowBuilder = class {
       "send-stream",
       config.name,
       {
-        message: config.message
+        message: config.message,
+        outputVariable: config.outputVariable,
+        errorHandling: config.errorHandling,
+        defaultValue: config.defaultValue
       },
       config.enabled,
       config.when
@@ -1311,7 +1315,6 @@ var FlowBuilder = class {
         fieldsToExclude: config.fieldsToExclude,
         availableFields: config.availableFields,
         outputVariable: config.outputVariable,
-        fields: config.fields,
         includeMetadata: config.includeMetadata,
         streamOutput: config.streamOutput
       },
@@ -1404,7 +1407,6 @@ var FlowBuilder = class {
         vectorStore: config.vectorStore,
         weaviateConfig: config.weaviateConfig,
         vectorizeConfig: config.vectorizeConfig,
-        pineconeConfig: config.pineconeConfig,
         limit: config.limit,
         threshold: config.threshold,
         metadataFilters: config.metadataFilters,
@@ -1433,7 +1435,6 @@ var FlowBuilder = class {
         recordType: config.recordType,
         recordName: config.recordName,
         textField: config.textField,
-        storeInRecord: config.storeInRecord,
         embeddingModel: config.embeddingModel,
         maxLength: config.maxLength,
         inputMode: config.inputMode,
@@ -1441,7 +1442,6 @@ var FlowBuilder = class {
         itemAlias: config.itemAlias,
         textTemplate: config.textTemplate,
         batchSize: config.batchSize,
-        vectorStore: config.vectorStore,
         outputVariable: config.outputVariable,
         streamOutput: config.streamOutput
       },
@@ -1490,51 +1490,6 @@ var FlowBuilder = class {
     );
     return this;
   }
-  /**
-   * Add a send text step
-   */
-  sendText(config) {
-    this.addStep(
-      "send-text",
-      config.name,
-      {
-        to: config.to,
-        from: config.from,
-        message: config.message,
-        outputVariable: config.outputVariable,
-        errorHandling: config.errorHandling,
-        streamOutput: config.streamOutput
-      },
-      config.enabled,
-      config.when
-    );
-    return this;
-  }
-  /**
-   * Add a fetch GitHub step
-   */
-  fetchGitHub(config) {
-    this.addStep(
-      "fetch-github",
-      config.name,
-      {
-        repository: config.repository,
-        branch: config.branch,
-        path: config.path,
-        token: config.token,
-        outputVariable: config.outputVariable,
-        contentType: config.contentType,
-        includePatterns: config.includePatterns,
-        excludePatterns: config.excludePatterns,
-        compress: config.compress,
-        style: config.style,
-        streamOutput: config.streamOutput
-      },
-      config.enabled,
-      config.when
-    );
-    return this;
-  }
   /** Add an api-call step. */
   apiCall(config) {
     return this.addRawStep("api-call", config);
@@ -1938,6 +1893,31 @@ function resolveBatchExecutionId(pausedTools) {
   return "";
 }
 
+// src/content-hash.ts
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeValue(item));
+  }
+  if (isPlainObject(value)) {
+    const normalized = {};
+    for (const key of Object.keys(value).sort()) {
+      const entry = value[key];
+      if (entry === void 0 || entry === null) continue;
+      normalized[key] = normalizeValue(entry);
+    }
+    return normalized;
+  }
+  return value;
+}
+async function sha256Hex(serialized) {
+  const encoded = new TextEncoder().encode(serialized);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", encoded);
+  return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
 // src/evals-ensure.ts
 var CHECK_GRADER_KINDS = /* @__PURE__ */ new Set([
   "contains",
@@ -2153,12 +2133,11 @@ var DEFINE_EVAL_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "target",
   "graders",
   "cases",
-  "virtual"
+  "virtual",
+  "recordedToolMode",
+  "recordedToolUnmatchedPolicy"
 ]);
 var DEFINE_EVAL_CASE_KEYS = /* @__PURE__ */ new Set(["name", "input", "expected", "expect"]);
-function isPlainObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
 function normalizeTarget(target) {
   if (!isPlainObject(target)) {
     throw new Error('defineEval requires a "target" object: { flow: name } or { agent: name }');
@@ -2225,9 +2204,15 @@ function defineEval(input) {
   const unknownKeys = Object.keys(input).filter((k) => !DEFINE_EVAL_TOP_LEVEL_KEYS.has(k));
   if (unknownKeys.length > 0) {
     throw new Error(
-      `defineEval: unknown field(s): ${unknownKeys.join(", ")}. Allowed fields are target, graders, cases, virtual.`
+      `defineEval: unknown field(s): ${unknownKeys.join(", ")}. Allowed fields are target, graders, cases, virtual, recordedToolMode, recordedToolUnmatchedPolicy.`
     );
   }
+  if (input.recordedToolMode !== void 0 && input.recordedToolMode !== "next_step" && input.recordedToolMode !== "continue") {
+    throw new Error('defineEval "recordedToolMode" must be "next_step" or "continue"');
+  }
+  if (input.recordedToolUnmatchedPolicy !== void 0 && input.recordedToolUnmatchedPolicy !== "fail" && input.recordedToolUnmatchedPolicy !== "stub") {
+    throw new Error('defineEval "recordedToolUnmatchedPolicy" must be "fail" or "stub"');
+  }
   const target = normalizeTarget(input.target);
   if (input.name !== void 0 && (typeof input.name !== "string" || input.name.length === 0)) {
     throw new Error('defineEval "name" must be a non-empty string when provided');
@@ -2276,7 +2261,14 @@ function defineEval(input) {
       expect
     };
   });
-  return { name, target, cases, virtual: input.virtual === true };
+  return {
+    name,
+    target,
+    cases,
+    virtual: input.virtual === true,
+    ...input.recordedToolMode !== void 0 ? { recordedToolMode: input.recordedToolMode } : {},
+    ...input.recordedToolUnmatchedPolicy !== void 0 ? { recordedToolUnmatchedPolicy: input.recordedToolUnmatchedPolicy } : {}
+  };
 }
 function normalizeForHash(value) {
   if (Array.isArray(value)) return value.map(normalizeForHash);
@@ -2292,9 +2284,13 @@ function normalizeForHash(value) {
   return value;
 }
 async function computeEvalContentHash(definition) {
+  const recordedToolMode = definition.recordedToolMode ?? "next_step";
+  const recordedToolUnmatchedPolicy = definition.recordedToolUnmatchedPolicy ?? "fail";
   const canonical = {
     target: normalizeForHash(definition.target),
     virtual: definition.virtual,
+    ...recordedToolMode !== "next_step" ? { recordedToolMode } : {},
+    ...recordedToolUnmatchedPolicy !== "fail" ? { recordedToolUnmatchedPolicy } : {},
     cases: [...definition.cases].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0).map((c) => ({
       name: c.name,
       input: normalizeForHash(c.input),
@@ -2303,10 +2299,7 @@ async function computeEvalContentHash(definition) {
       expect: c.expect.map((g) => normalizeForHash(g))
     }))
   };
-  const serialized = JSON.stringify(canonical);
-  const encoded = new TextEncoder().encode(serialized);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", encoded);
-  return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return sha256Hex(JSON.stringify(canonical));
 }
 var serverHashMemo = /* @__PURE__ */ new WeakMap();
 function memoFor(client) {
@@ -2353,11 +2346,8 @@ async function runEvalSuite(client, input) {
 }
 
 // src/flows-ensure.ts
-function isPlainObject2(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
 function normalizeConfigForHash(config) {
-  if (!isPlainObject2(config)) return {};
+  if (!isPlainObject(config)) return {};
   const normalized = {};
   for (const key of Object.keys(config).sort()) {
     const value = config[key];
@@ -2378,7 +2368,7 @@ function normalizeConfigForHash(config) {
   return normalized;
 }
 function normalizeStepForHash(step) {
-  const stepObj = isPlainObject2(step) ? step : {};
+  const stepObj = isPlainObject(step) ? step : {};
   return {
     type: typeof stepObj.type === "string" ? stepObj.type : "",
     name: typeof stepObj.name === "string" ? stepObj.name : "",
@@ -2390,14 +2380,11 @@ function normalizeStepForHash(step) {
 }
 async function computeFlowContentHash(steps) {
   const normalized = [...steps].sort((a, b) => {
-    const orderA = isPlainObject2(a) && typeof a.order === "number" ? a.order : 0;
-    const orderB = isPlainObject2(b) && typeof b.order === "number" ? b.order : 0;
+    const orderA = isPlainObject(a) && typeof a.order === "number" ? a.order : 0;
+    const orderB = isPlainObject(b) && typeof b.order === "number" ? b.order : 0;
     return orderA - orderB;
   }).map(normalizeStepForHash);
-  const serialized = JSON.stringify(normalized);
-  const encoded = new TextEncoder().encode(serialized);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", encoded);
-  return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return sha256Hex(JSON.stringify(normalized));
 }
 var DEFINE_FLOW_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set(["name", "steps", "evals"]);
 var DEFINE_FLOW_STEP_KEYS = /* @__PURE__ */ new Set([
@@ -2420,27 +2407,27 @@ function collectStepNonPortableToolRefs(config, path) {
     });
   };
   const scanKeys = (value, subPath) => {
-    if (!isPlainObject2(value)) return;
+    if (!isPlainObject(value)) return;
     for (const key of Object.keys(value)) {
       if (isAccountScoped(key)) found.push(`${subPath}.${key}`);
     }
   };
-  if (isPlainObject2(tools)) {
+  if (isPlainObject(tools)) {
     scanArray(tools.toolIds, `${path}.tools.toolIds`);
     scanKeys(tools.toolConfigs, `${path}.tools.toolConfigs`);
     scanKeys(tools.perToolLimits, `${path}.tools.perToolLimits`);
-    if (isPlainObject2(tools.approval)) {
+    if (isPlainObject(tools.approval)) {
       scanArray(tools.approval.require, `${path}.tools.approval.require`);
     }
-    if (isPlainObject2(tools.subagentConfig)) {
+    if (isPlainObject(tools.subagentConfig)) {
       scanArray(tools.subagentConfig.toolPool, `${path}.tools.subagentConfig.toolPool`);
     }
-    if (isPlainObject2(tools.codeModeConfig)) {
+    if (isPlainObject(tools.codeModeConfig)) {
       scanArray(tools.codeModeConfig.toolPool, `${path}.tools.codeModeConfig.toolPool`);
     }
     if (Array.isArray(tools.runtimeTools)) {
       tools.runtimeTools.forEach((runtimeTool, i) => {
-        if (!isPlainObject2(runtimeTool) || !isPlainObject2(runtimeTool.config)) return;
+        if (!isPlainObject(runtimeTool) || !isPlainObject(runtimeTool.config)) return;
         const base = `${path}.tools.runtimeTools[${i}].config`;
         const rtConfig = runtimeTool.config;
         if (runtimeTool.toolType === "subagent" && isRawId(rtConfig.agentId, "agent_")) {
@@ -2461,7 +2448,7 @@ function collectStepNonPortableToolRefs(config, path) {
     const nested = config[branch];
     if (!Array.isArray(nested)) continue;
     nested.forEach((nestedStep, i) => {
-      if (isPlainObject2(nestedStep) && isPlainObject2(nestedStep.config)) {
+      if (isPlainObject(nestedStep) && isPlainObject(nestedStep.config)) {
         found.push(
           ...collectStepNonPortableToolRefs(nestedStep.config, `${path}.${branch}[${i}].config`)
         );
@@ -2487,7 +2474,7 @@ function defineFlow(input) {
     throw new Error('defineFlow requires a non-empty "steps" array');
   }
   const steps = input.steps.map((step, index) => {
-    if (!isPlainObject2(step)) {
+    if (!isPlainObject(step)) {
       throw new Error(`defineFlow: steps[${index}] must be an object`);
     }
     if (typeof step.type !== "string" || step.type.length === 0) {
@@ -2502,7 +2489,7 @@ function defineFlow(input) {
         `defineFlow: steps[${index}] has unknown field(s): ${unknownStepKeys.join(", ")}. Allowed step fields are type, name, order, enabled, when, config. (Step ids are server artifacts and not part of a portable definition.)`
       );
     }
-    const config = isPlainObject2(step.config) ? step.config : void 0;
+    const config = isPlainObject(step.config) ? step.config : void 0;
     if (config) {
       const nonPortable = collectStepNonPortableToolRefs(config, `steps[${index}].config`);
       if (nonPortable.length > 0) {
@@ -2529,7 +2516,7 @@ function defineFlow(input) {
     }
     const seenEvalNames = /* @__PURE__ */ new Set();
     evals = input.evals.map((evalInput, i) => {
-      if (!isPlainObject2(evalInput)) {
+      if (!isPlainObject(evalInput)) {
         throw new Error(`defineFlow: evals[${i}] must be an object`);
       }
       if (evalInput.virtual === true) {
@@ -2593,7 +2580,7 @@ function parseRequestError(err) {
 }
 function toConflictError(err) {
   const { status, body } = parseRequestError(err);
-  if (status !== 409 || !isPlainObject2(body)) return null;
+  if (status !== 409 || !isPlainObject(body)) return null;
   const code = body.code;
   if (code !== "external_modification" && code !== "remote_changed") return null;
   return new FlowEnsureConflictError(
@@ -2958,6 +2945,7 @@ var RuntypeFlowBuilder = class {
         markdownIfAvailable: config.markdownIfAvailable,
         fetchMethod: config.fetchMethod === "http" ? "standard" : config.fetchMethod,
         firecrawl: config.firecrawl,
+        massive: config.massive,
         outputVariable: config.outputVariable,
         errorHandling: config.errorHandling,
         defaultValue: config.defaultValue,
@@ -3118,7 +3106,6 @@ var RuntypeFlowBuilder = class {
         fieldsToExclude: config.fieldsToExclude,
         availableFields: config.availableFields,
         outputVariable: config.outputVariable,
-        fields: config.fields,
         includeMetadata: config.includeMetadata,
         streamOutput: config.streamOutput
       },
@@ -3211,7 +3198,6 @@ var RuntypeFlowBuilder = class {
         vectorStore: config.vectorStore,
         weaviateConfig: config.weaviateConfig,
         vectorizeConfig: config.vectorizeConfig,
-        pineconeConfig: config.pineconeConfig,
         limit: config.limit,
         threshold: config.threshold,
         metadataFilters: config.metadataFilters,
@@ -3240,7 +3226,6 @@ var RuntypeFlowBuilder = class {
         recordType: config.recordType,
         recordName: config.recordName,
         textField: config.textField,
-        storeInRecord: config.storeInRecord,
         embeddingModel: config.embeddingModel,
         maxLength: config.maxLength,
         inputMode: config.inputMode,
@@ -3248,7 +3233,6 @@ var RuntypeFlowBuilder = class {
         itemAlias: config.itemAlias,
         textTemplate: config.textTemplate,
         batchSize: config.batchSize,
-        vectorStore: config.vectorStore,
         outputVariable: config.outputVariable,
         streamOutput: config.streamOutput
       },
@@ -3297,51 +3281,6 @@ var RuntypeFlowBuilder = class {
     );
     return this;
   }
-  /**
-   * Add a send text step
-   */
-  sendText(config) {
-    this.addStep(
-      "send-text",
-      config.name,
-      {
-        to: config.to,
-        from: config.from,
-        message: config.message,
-        outputVariable: config.outputVariable,
-        errorHandling: config.errorHandling,
-        streamOutput: config.streamOutput
-      },
-      config.enabled,
-      config.when
-    );
-    return this;
-  }
-  /**
-   * Add a fetch GitHub step
-   */
-  fetchGitHub(config) {
-    this.addStep(
-      "fetch-github",
-      config.name,
-      {
-        repository: config.repository,
-        branch: config.branch,
-        path: config.path,
-        token: config.token,
-        outputVariable: config.outputVariable,
-        contentType: config.contentType,
-        includePatterns: config.includePatterns,
-        excludePatterns: config.excludePatterns,
-        compress: config.compress,
-        style: config.style,
-        streamOutput: config.streamOutput
-      },
-      config.enabled,
-      config.when
-    );
-    return this;
-  }
   /** Add an api-call step. */
   apiCall(config) {
     return this.addRawStep("api-call", config);
@@ -3888,6 +3827,30 @@ var EvalSuitesNamespace = class {
       cases
     });
   }
+  /**
+   * Capture a test case from a real agent run ("fork here and test the next
+   * step"): freezes the run's conversation history up to a fork point, attaches
+   * every recorded tool result as an editable mock, and saves it with origin
+   * `saved_from_run`. Capture only — reads the run, never re-executes it.
+   */
+  async addCaseFromExecution(suiteId, input) {
+    return this.getClient().post(
+      `/eval/suites/${suiteId}/cases/from-execution`,
+      input
+    );
+  }
+  /**
+   * Dry-run of {@link addCaseFromExecution}: reconstruct an agent execution
+   * exactly as capture would and return its recorded actions plus the fork
+   * index each maps to (and whether the case would be fully replayable), so a
+   * caller can build a fork picker without re-deriving the seed math. Reads
+   * only — nothing is written.
+   */
+  async getCapturePreview(executionId) {
+    return this.getClient().get(
+      `/eval/executions/${executionId}/capture-preview`
+    );
+  }
   /** Edit, enable, or disable a test case. */
   async updateCase(suiteId, caseId, input) {
     return this.getClient().patch(
@@ -3901,6 +3864,55 @@ var EvalSuitesNamespace = class {
       `/eval/suites/${suiteId}/cases/${caseId}`
     );
   }
+  /**
+   * List a suite's machine-proposed cases (the review queue). Every
+   * generation source lands here; nothing enters the suite without an accept.
+   */
+  async listProposals(suiteId, params) {
+    return this.getClient().get(
+      `/eval/suites/${suiteId}/proposals`,
+      params
+    );
+  }
+  /**
+   * Accept a proposal — materializes it as an eval case and backlinks it.
+   * Pass `options.case` to save an edited body instead (recorded as
+   * `edited_accepted`; the machine original stays on the proposal for audit).
+   */
+  async acceptProposal(suiteId, proposalId, options) {
+    return this.getClient().post(
+      `/eval/suites/${suiteId}/proposals/${proposalId}/accept`,
+      options ?? {}
+    );
+  }
+  /** Reject a proposal. The row survives as audit. */
+  async rejectProposal(suiteId, proposalId) {
+    return this.getClient().post(
+      `/eval/suites/${suiteId}/proposals/${proposalId}/reject`,
+      {}
+    );
+  }
+  /**
+   * Generate test-case proposals from the target's definition, fanned out
+   * over an explicit diversity matrix (category × persona) and filtered for
+   * gradeability. Results land as PROPOSALS for review — never directly in
+   * the suite. Reserves one daily-eval quota slot per call.
+   */
+  async generateCases(suiteId, input) {
+    return this.getClient().post(
+      `/eval/suites/${suiteId}/generate-cases`,
+      input ?? {}
+    );
+  }
+  /**
+   * The coverage meter: which of the target's tools and instruction clauses
+   * the suite's cases and graders already exercise. The instruction inventory
+   * is cached server-side and refreshed when the definition changes; a cache
+   * miss spends a metered model call, so this requires eval-write scope.
+   */
+  async getCoverage(suiteId) {
+    return this.getClient().get(`/eval/suites/${suiteId}/coverage`);
+  }
 };
 
 // src/evals-namespace.ts
@@ -4074,6 +4086,30 @@ var EvalsNamespace = class {
   async pull(name) {
     return pullEval(this.getClient(), name);
   }
+  /**
+   * Split one plain-language AI-grader criterion carrying several obligations
+   * into focused, independently judgeable sub-checks. Authoring assist only:
+   * nothing is persisted — review the proposal, then save each accepted
+   * sub-check as its own AI grader row. A single returned sub-check means the
+   * criterion is already focused.
+   *
+   * @example
+   * ```typescript
+   * const { subChecks } = await Runtype.evals.decomposeCriteria(
+   *   'Confirms the order number before issuing a refund, and never promises a delivery date.'
+   * )
+   * // In a defineEval suite, each accepted sub-check becomes its own judge row:
+   * const graders = subChecks.map((s) => judge(s.criteria))
+   * ```
+   */
+  async decomposeCriteria(criteria) {
+    if (typeof criteria !== "string" || criteria.trim().length === 0) {
+      throw new Error("decomposeCriteria() requires non-empty criteria");
+    }
+    return this.getClient().post("/eval/graders/decompose", {
+      criteria
+    });
+  }
   /**
    * Run an eval suite synchronously and return the suite score + per-case grader
    * outcomes — the executing counterpart of `ensure`, powering the `runtype
@@ -4108,6 +4144,28 @@ var EvalsNamespace = class {
     const client = this.getClient();
     return client.get(`/eval/runs/${runId}/scores`);
   }
+  /**
+   * Record a lightweight human review of one AI-grader verdict ("the grader
+   * got this right / wrong"), using the `scoreId` on a persisted outcome from
+   * `getRunScores`. Reviews accumulate into the suite's judge-trust display
+   * ("agrees with you N of M times"). Pass `null` to clear an earlier review.
+   *
+   * @example
+   * ```typescript
+   * const scores = await Runtype.evals.getRunScores(runId)
+   * const outcome = scores.cases[0]?.outcomes.find((o) => o.kind === 'ai')
+   * if (outcome?.scoreId) {
+   *   await Runtype.evals.reviewScore(outcome.scoreId, 'disagree')
+   * }
+   * ```
+   */
+  async reviewScore(scoreId, verdict) {
+    const client = this.getClient();
+    return client.post(
+      `/eval/scores/${scoreId}/review`,
+      { verdict }
+    );
+  }
   /**
    * Get evaluation status by ID
    *
@@ -4226,42 +4284,21 @@ var PromptsNamespace = class {
 };
 
 // src/skills-ensure.ts
-function isPlainObject3(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function normalizeValue(value) {
-  if (Array.isArray(value)) {
-    return value.map((item) => normalizeValue(item));
-  }
-  if (isPlainObject3(value)) {
-    const normalized = {};
-    for (const key of Object.keys(value).sort()) {
-      const entry = value[key];
-      if (entry === void 0 || entry === null) continue;
-      normalized[key] = normalizeValue(entry);
-    }
-    return normalized;
-  }
-  return value;
-}
 function normalizeSkillDefinition(definition) {
-  const manifest = isPlainObject3(definition.manifest) ? definition.manifest : {};
-  const rawFrontmatter = isPlainObject3(manifest.frontmatter) ? manifest.frontmatter : {};
+  const manifest = isPlainObject(definition.manifest) ? definition.manifest : {};
+  const rawFrontmatter = isPlainObject(manifest.frontmatter) ? manifest.frontmatter : {};
   const frontmatterWithoutName = {};
   for (const key of Object.keys(rawFrontmatter)) {
     if (key === "name") continue;
     frontmatterWithoutName[key] = rawFrontmatter[key];
   }
   const frontmatter = normalizeValue(frontmatterWithoutName);
-  const runtype = isPlainObject3(manifest.runtype) ? normalizeValue(manifest.runtype) : {};
+  const runtype = isPlainObject(manifest.runtype) ? normalizeValue(manifest.runtype) : {};
   const body = typeof manifest.body === "string" ? manifest.body : "";
   return { frontmatter, runtype, body };
 }
 async function computeSkillContentHash(definition) {
-  const serialized = JSON.stringify(normalizeSkillDefinition(definition));
-  const encoded = new TextEncoder().encode(serialized);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", encoded);
-  return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return sha256Hex(JSON.stringify(normalizeSkillDefinition(definition)));
 }
 var DEFINE_SKILL_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set(["name", "manifest"]);
 function defineSkill(input) {
@@ -4271,7 +4308,7 @@ function defineSkill(input) {
   if (typeof input.name !== "string" || input.name.length === 0) {
     throw new Error('defineSkill requires a non-empty string "name"');
   }
-  if (!isPlainObject3(input.manifest)) {
+  if (!isPlainObject(input.manifest)) {
     throw new Error('defineSkill requires a "manifest" object ({ frontmatter, runtype, body })');
   }
   const unknownKeys = Object.keys(input).filter((key) => !DEFINE_SKILL_TOP_LEVEL_KEYS.has(key));
@@ -4281,7 +4318,7 @@ function defineSkill(input) {
     );
   }
   const frontmatter = input.manifest.frontmatter;
-  if (!isPlainObject3(frontmatter) || typeof frontmatter.name !== "string") {
+  if (!isPlainObject(frontmatter) || typeof frontmatter.name !== "string") {
     throw new Error("defineSkill: manifest.frontmatter.name is required");
   }
   if (frontmatter.name !== input.name) {
@@ -4322,7 +4359,7 @@ function parseRequestError2(err) {
 }
 function toConflictError2(err) {
   const { status, body } = parseRequestError2(err);
-  if (status !== 409 || !isPlainObject3(body)) return null;
+  if (status !== 409 || !isPlainObject(body)) return null;
   const code = body.code;
   if (code !== "external_modification" && code !== "remote_changed") return null;
   return new SkillEnsureConflictError(
@@ -4671,14 +4708,14 @@ var AGENT_CONFIG_KEYS = [
   "tenancyStrategy"
 ];
 var AGENT_CONFIG_KEY_LIST = [...AGENT_CONFIG_KEYS].sort();
-function isPlainObject4(value) {
+function isPlainObject2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function normalizeValue2(value) {
   if (Array.isArray(value)) {
     return value.map((item) => normalizeValue2(item));
   }
-  if (isPlainObject4(value)) {
+  if (isPlainObject2(value)) {
     const normalized = {};
     for (const key of Object.keys(value).sort()) {
       const entry = value[key];
@@ -4691,7 +4728,7 @@ function normalizeValue2(value) {
 }
 function normalizeAgentDefinition(definition) {
   const config = {};
-  const rawConfig = isPlainObject4(definition.config) ? definition.config : {};
+  const rawConfig = isPlainObject2(definition.config) ? definition.config : {};
   for (const key of AGENT_CONFIG_KEY_LIST) {
     const value = rawConfig[key];
     if (value === void 0 || value === null) continue;
@@ -4713,7 +4750,7 @@ async function computeAgentContentHash(definition) {
 var DEFINE_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set(["name", "description", "icon", ...AGENT_CONFIG_KEYS]);
 function collectNonPortableToolRefs(config) {
   const tools = config.tools;
-  if (!isPlainObject4(tools)) return [];
+  if (!isPlainObject2(tools)) return [];
   const found = [];
   const isAccountScoped = (ref) => typeof ref === "string" && ref.startsWith("tool_");
   const scanArray = (value, path) => {
@@ -4723,7 +4760,7 @@ function collectNonPortableToolRefs(config) {
     });
   };
   const scanKeys = (value, path) => {
-    if (!isPlainObject4(value)) return;
+    if (!isPlainObject2(value)) return;
     for (const key of Object.keys(value)) {
       if (isAccountScoped(key)) found.push(`${path}.${key}`);
     }
@@ -4731,16 +4768,16 @@ function collectNonPortableToolRefs(config) {
   scanArray(tools.toolIds, "tools.toolIds");
   scanKeys(tools.toolConfigs, "tools.toolConfigs");
   scanKeys(tools.perToolLimits, "tools.perToolLimits");
-  if (isPlainObject4(tools.approval)) scanArray(tools.approval.require, "tools.approval.require");
-  if (isPlainObject4(tools.subagentConfig)) {
+  if (isPlainObject2(tools.approval)) scanArray(tools.approval.require, "tools.approval.require");
+  if (isPlainObject2(tools.subagentConfig)) {
     scanArray(tools.subagentConfig.toolPool, "tools.subagentConfig.toolPool");
   }
-  if (isPlainObject4(tools.codeModeConfig)) {
+  if (isPlainObject2(tools.codeModeConfig)) {
     scanArray(tools.codeModeConfig.toolPool, "tools.codeModeConfig.toolPool");
   }
   if (Array.isArray(tools.runtimeTools)) {
     tools.runtimeTools.forEach((runtimeTool, i) => {
-      if (!isPlainObject4(runtimeTool) || !isPlainObject4(runtimeTool.config)) return;
+      if (!isPlainObject2(runtimeTool) || !isPlainObject2(runtimeTool.config)) return;
       const base = `tools.runtimeTools[${i}].config`;
       const rtConfig = runtimeTool.config;
       if (runtimeTool.toolType === "subagent" && typeof rtConfig.agentId === "string" && rtConfig.agentId.startsWith("agent_")) {
@@ -4814,7 +4851,7 @@ function parseRequestError3(err) {
 }
 function toConflictError3(err) {
   const { status, body } = parseRequestError3(err);
-  if (status !== 409 || !isPlainObject4(body)) return null;
+  if (status !== 409 || !isPlainObject2(body)) return null;
   const code = body.code;
   if (code !== "external_modification" && code !== "remote_changed") return null;
   return new AgentEnsureConflictError(
@@ -4916,27 +4953,9 @@ var AgentsNamespace = class {
 };
 
 // src/tools-ensure.ts
-function isPlainObject5(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function normalizeValue3(value) {
-  if (Array.isArray(value)) {
-    return value.map((item) => normalizeValue3(item));
-  }
-  if (isPlainObject5(value)) {
-    const normalized = {};
-    for (const key of Object.keys(value).sort()) {
-      const entry = value[key];
-      if (entry === void 0 || entry === null) continue;
-      normalized[key] = normalizeValue3(entry);
-    }
-    return normalized;
-  }
-  return value;
-}
 function normalizeToolDefinition(definition) {
-  const parametersSchema = isPlainObject5(definition.parametersSchema) ? normalizeValue3(definition.parametersSchema) : {};
-  const config = isPlainObject5(definition.config) ? normalizeValue3(definition.config) : {};
+  const parametersSchema = isPlainObject(definition.parametersSchema) ? normalizeValue(definition.parametersSchema) : {};
+  const config = isPlainObject(definition.config) ? normalizeValue(definition.config) : {};
   return {
     toolType: definition.toolType,
     ...definition.description ? { description: definition.description } : {},
@@ -4945,10 +4964,7 @@ function normalizeToolDefinition(definition) {
   };
 }
 async function computeToolContentHash(definition) {
-  const serialized = JSON.stringify(normalizeToolDefinition(definition));
-  const encoded = new TextEncoder().encode(serialized);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", encoded);
-  return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return sha256Hex(JSON.stringify(normalizeToolDefinition(definition)));
 }
 var DEFINE_TOOL_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "name",
@@ -4981,10 +4997,10 @@ function defineTool(input) {
       `defineTool requires "toolType" to be one of: ${[...TOOL_DEFINITION_TYPES].join(", ")}`
     );
   }
-  if (!isPlainObject5(input.parametersSchema)) {
+  if (!isPlainObject(input.parametersSchema)) {
     throw new Error('defineTool requires a "parametersSchema" object (a JSON Schema)');
   }
-  if (!isPlainObject5(input.config)) {
+  if (!isPlainObject(input.config)) {
     throw new Error('defineTool requires a "config" object');
   }
   const unknownKeys = Object.keys(input).filter((key) => !DEFINE_TOOL_TOP_LEVEL_KEYS.has(key));
@@ -5032,7 +5048,7 @@ function parseRequestError4(err) {
 }
 function toConflictError4(err) {
   const { status, body } = parseRequestError4(err);
-  if (status !== 409 || !isPlainObject5(body)) return null;
+  if (status !== 409 || !isPlainObject(body)) return null;
   const code = body.code;
   if (code !== "external_modification" && code !== "remote_changed") return null;
   return new ToolEnsureConflictError(
@@ -5152,26 +5168,8 @@ var ToolsNamespace = class {
 };
 
 // src/products-ensure.ts
-function isPlainObject6(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function normalizeValue4(value) {
-  if (Array.isArray(value)) {
-    return value.map((item) => normalizeValue4(item));
-  }
-  if (isPlainObject6(value)) {
-    const normalized = {};
-    for (const key of Object.keys(value).sort()) {
-      const entry = value[key];
-      if (entry === void 0 || entry === null) continue;
-      normalized[key] = normalizeValue4(entry);
-    }
-    return normalized;
-  }
-  return value;
-}
 function normalizeProductDefinition(definition) {
-  const spec = isPlainObject6(definition.spec) ? normalizeValue4(definition.spec) : {};
+  const spec = isPlainObject(definition.spec) ? normalizeValue(definition.spec) : {};
   return {
     ...definition.description ? { description: definition.description } : {},
     ...definition.icon ? { icon: definition.icon } : {},
@@ -5179,10 +5177,7 @@ function normalizeProductDefinition(definition) {
   };
 }
 async function computeProductContentHash(definition) {
-  const serialized = JSON.stringify(normalizeProductDefinition(definition));
-  const encoded = new TextEncoder().encode(serialized);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", encoded);
-  return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return sha256Hex(JSON.stringify(normalizeProductDefinition(definition)));
 }
 var DEFINE_PRODUCT_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set(["name", "description", "icon", "spec"]);
 function defineProduct(input) {
@@ -5198,7 +5193,7 @@ function defineProduct(input) {
   if (input.icon != null && typeof input.icon !== "string") {
     throw new Error('defineProduct "icon" must be a string when provided');
   }
-  if (input.spec != null && !isPlainObject6(input.spec)) {
+  if (input.spec != null && !isPlainObject(input.spec)) {
     throw new Error('defineProduct "spec" must be an object when provided');
   }
   const unknownKeys = Object.keys(input).filter((key) => !DEFINE_PRODUCT_TOP_LEVEL_KEYS.has(key));
@@ -5245,7 +5240,7 @@ function parseRequestError5(err) {
 }
 function toConflictError5(err) {
   const { status, body } = parseRequestError5(err);
-  if (status !== 409 || !isPlainObject6(body)) return null;
+  if (status !== 409 || !isPlainObject(body)) return null;
   const code = body.code;
   if (code !== "external_modification" && code !== "remote_changed") return null;
   return new ProductEnsureConflictError(
@@ -5326,50 +5321,31 @@ async function pullProduct(client, name) {
 }
 
 // src/products-ensure-fpo.ts
-function isPlainObject7(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function normalizeValue5(value) {
-  if (Array.isArray(value)) {
-    return value.map((item) => normalizeValue5(item));
-  }
-  if (isPlainObject7(value)) {
-    const normalized = {};
-    for (const key of Object.keys(value).sort()) {
-      const entry = value[key];
-      if (entry === void 0 || entry === null) continue;
-      normalized[key] = normalizeValue5(entry);
-    }
-    return normalized;
-  }
-  return value;
-}
 function normalizeFpoDefinition(fpo) {
-  const productInput = isPlainObject7(fpo.product) ? fpo.product : {};
+  const productInput = isPlainObject(fpo.product) ? fpo.product : {};
   const { name: _identityName, ...productRest } = productInput;
-  const product = normalizeValue5(productRest);
+  const product = normalizeValue(productRest);
   return {
-    ...fpo.version !== void 0 && fpo.version !== null ? { version: normalizeValue5(fpo.version) } : {},
+    ...fpo.version !== void 0 && fpo.version !== null ? { version: normalizeValue(fpo.version) } : {},
     product,
-    capabilities: normalizeValue5(fpo.capabilities ?? []),
-    tools: normalizeValue5(fpo.tools ?? []),
-    surfaces: normalizeValue5(fpo.surfaces ?? []),
-    ...fpo.records !== void 0 && fpo.records !== null ? { records: normalizeValue5(fpo.records) } : {},
-    ...fpo.schedules !== void 0 && fpo.schedules !== null ? { schedules: normalizeValue5(fpo.schedules) } : {},
-    ...fpo.secrets !== void 0 && fpo.secrets !== null ? { secrets: normalizeValue5(fpo.secrets) } : {}
+    capabilities: normalizeValue(fpo.capabilities ?? []),
+    tools: normalizeValue(fpo.tools ?? []),
+    surfaces: normalizeValue(fpo.surfaces ?? []),
+    ...fpo.records !== void 0 && fpo.records !== null ? { records: normalizeValue(fpo.records) } : {},
+    ...fpo.schedules !== void 0 && fpo.schedules !== null ? { schedules: normalizeValue(fpo.schedules) } : {},
+    ...fpo.secrets !== void 0 && fpo.secrets !== null ? { secrets: normalizeValue(fpo.secrets) } : {},
+    ...fpo.evals !== void 0 && fpo.evals !== null ? { evals: normalizeValue(fpo.evals) } : {},
+    ...fpo.skills !== void 0 && fpo.skills !== null ? { skills: normalizeValue(fpo.skills) } : {}
   };
 }
 async function computeFpoContentHash(fpo) {
-  const serialized = JSON.stringify(normalizeFpoDefinition(fpo));
-  const encoded = new TextEncoder().encode(serialized);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", encoded);
-  return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return sha256Hex(JSON.stringify(normalizeFpoDefinition(fpo)));
 }
 function defineFpo(fpo) {
-  if (!isPlainObject7(fpo)) {
+  if (!isPlainObject(fpo)) {
     throw new Error("defineFpo requires an FPO object");
   }
-  const product = isPlainObject7(fpo.product) ? fpo.product : void 0;
+  const product = isPlainObject(fpo.product) ? fpo.product : void 0;
   if (!product || typeof product.name !== "string" || product.name.length === 0) {
     throw new Error('defineFpo requires a non-empty "product.name" (the converge identity)');
   }
@@ -5465,26 +5441,8 @@ var ProductsNamespace = class {
 };
 
 // src/surfaces-ensure.ts
-function isPlainObject8(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function normalizeValue6(value) {
-  if (Array.isArray(value)) {
-    return value.map((item) => normalizeValue6(item));
-  }
-  if (isPlainObject8(value)) {
-    const normalized = {};
-    for (const key of Object.keys(value).sort()) {
-      const entry = value[key];
-      if (entry === void 0 || entry === null) continue;
-      normalized[key] = normalizeValue6(entry);
-    }
-    return normalized;
-  }
-  return value;
-}
 function normalizeSurfaceDefinition(definition) {
-  const behavior = isPlainObject8(definition.behavior) ? normalizeValue6({ type: definition.type, ...definition.behavior }) : { type: definition.type };
+  const behavior = isPlainObject(definition.behavior) ? normalizeValue({ type: definition.type, ...definition.behavior }) : { type: definition.type };
   return {
     type: definition.type,
     behavior,
@@ -5493,10 +5451,7 @@ function normalizeSurfaceDefinition(definition) {
   };
 }
 async function computeSurfaceContentHash(definition) {
-  const serialized = JSON.stringify(normalizeSurfaceDefinition(definition));
-  const encoded = new TextEncoder().encode(serialized);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", encoded);
-  return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return sha256Hex(JSON.stringify(normalizeSurfaceDefinition(definition)));
 }
 var DEFINE_SURFACE_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "name",
@@ -5537,13 +5492,13 @@ function defineSurface(input) {
       `defineSurface requires "type" to be one of: ${[...SURFACE_DEFINITION_TYPES].join(", ")}`
     );
   }
-  if (input.behavior !== void 0 && !isPlainObject8(input.behavior)) {
+  if (input.behavior !== void 0 && !isPlainObject(input.behavior)) {
     throw new Error('defineSurface "behavior" must be an object when provided');
   }
-  if (input.inbound !== void 0 && !isPlainObject8(input.inbound)) {
+  if (input.inbound !== void 0 && !isPlainObject(input.inbound)) {
     throw new Error('defineSurface "inbound" must be an object when provided');
   }
-  if (input.outbound !== void 0 && !isPlainObject8(input.outbound)) {
+  if (input.outbound !== void 0 && !isPlainObject(input.outbound)) {
     throw new Error('defineSurface "outbound" must be an object when provided');
   }
   if (input.status !== void 0 && !["draft", "active", "paused"].includes(input.status)) {
@@ -5599,7 +5554,7 @@ function parseRequestError6(err) {
 }
 function toConflictError6(err) {
   const { status, body } = parseRequestError6(err);
-  if (status !== 409 || !isPlainObject8(body)) return null;
+  if (status !== 409 || !isPlainObject(body)) return null;
   const code = body.code;
   if (code !== "external_modification" && code !== "remote_changed") return null;
   return new SurfaceEnsureConflictError(
@@ -6212,7 +6167,7 @@ var Runtype = class {
 
 // src/version.ts
 var FALLBACK_VERSION = "0.0.0";
-var SDK_VERSION = "5.9.0".length > 0 ? "5.9.0" : FALLBACK_VERSION;
+var SDK_VERSION = "6.1.3".length > 0 ? "6.1.3" : FALLBACK_VERSION;
 var RUNTYPE_CLIENT_KIND = "sdk";
 var SDK_USER_AGENT = `runtype-sdk/${SDK_VERSION} (typescript)`;
 
@@ -8456,6 +8411,69 @@ var RecordsEndpoint = class {
     });
   }
 };
+var CollectionsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List collections with cursor pagination. `includeCount: true` adds
+   * per-collection record counts.
+   */
+  async list(params) {
+    return this.client.get("/collections", params);
+  }
+  /**
+   * Get a collection by slug. `includeHistory: true` embeds the append-only
+   * schema version history.
+   */
+  async get(slug, params) {
+    return this.client.get(`/collections/${slug}`, params);
+  }
+  /**
+   * Register a record type as a collection. `validationMode` defaults to
+   * `off`, so creating a collection changes no existing behavior.
+   */
+  async create(data) {
+    return this.client.post("/collections", data);
+  }
+  /**
+   * Update display fields, validation mode, or the schema. Breaking schema
+   * changes are rejected while the resulting mode is `enforce`; transitioning
+   * to `enforce` returns an `enforceCheck` dry-run summary.
+   */
+  async update(slug, data) {
+    return this.client.patch(`/collections/${slug}`, data);
+  }
+  /**
+   * Delete the collection REGISTRATION only — records of the type are not
+   * touched and revert to schemaless behavior.
+   */
+  async delete(slug) {
+    return this.client.delete(`/collections/${slug}`);
+  }
+  /**
+   * Sample the type's most recently updated records and return a PROPOSED
+   * schema with per-field confidence and sample values. Saves nothing —
+   * review the proposal, then `update()` the collection.
+   */
+  async inferSchema(slug, params) {
+    return this.client.post(
+      `/collections/${slug}/infer-schema`,
+      params ?? {}
+    );
+  }
+  /**
+   * Dry-run existing records against a schema without writing anything — the
+   * "N of M records would fail" preview before enabling `enforce`. Uses the
+   * provided schema when given, otherwise the collection's saved schema.
+   */
+  async validateExisting(slug, data) {
+    return this.client.post(
+      `/collections/${slug}/validate-existing`,
+      data ?? {}
+    );
+  }
+};
 var ApiKeysEndpoint = class {
   constructor(client) {
     this.client = client;
@@ -9075,13 +9093,21 @@ var ClientTokensEndpoint = class {
   constructor(client) {
     this.client = client;
   }
-  /**
-   * List all client tokens for the authenticated user
-   */
-  async list() {
-    const response = await this.client.get(
-      "/client-tokens"
-    );
+  async list(params) {
+    const response = await this.client.get("/client-tokens", params);
+    if (params?.limit !== void 0) {
+      return {
+        clientTokens: response.clientTokens,
+        // The API always includes pagination when limit is supplied; the
+        // fallback mirrors the server's own envelope math so the paged
+        // overload stays total against older API deployments.
+        pagination: response.pagination ?? {
+          limit: params.limit,
+          offset: params.offset ?? 0,
+          hasMore: response.clientTokens.length === params.limit
+        }
+      };
+    }
     return response.clientTokens;
   }
   /**
@@ -12501,6 +12527,22 @@ var IntegrationsEndpoint = class {
   async installSlack(data) {
     return this.client.post("/integrations/slack/install", data);
   }
+  /**
+   * Start the Slack "Add to Slack" OAuth handshake. Returns the Slack authorize
+   * URL to open in a popup; the bot token is captured server-side by the
+   * callback (never returned to the browser).
+   */
+  async startSlackOAuth(data) {
+    return this.client.post("/oauth/slack/start", data);
+  }
+  /**
+   * Generate the Slack app manifest and one-click create-app deep link for a
+   * surface. The manifest carries absolute API URLs derived server-side, so it
+   * is always valid for Slack (relative proxy paths never leak in).
+   */
+  async generateSlackManifest(data) {
+    return this.client.post("/integrations/slack/manifest", data);
+  }
 };
 var BillingEndpoint = class {
   constructor(client) {
@@ -12519,7 +12561,15 @@ var BillingEndpoint = class {
     return this.client.get("/billing/credits");
   }
   /**
-   * Get spend analytics. The window is controlled by `days` (1–365, defaults to 30).
+   * Get the caller's exact current UTC-month platform spend from the local
+   * meter used for spend-cap enforcement. Returns 503 when that meter is unavailable.
+   */
+  async getCurrentSpend() {
+    return this.client.get("/billing/current-spend");
+  }
+  /**
+   * Get spend analytics. The window is controlled by either `period` or `days`
+   * (1–365, defaults to 30).
    */
   async getSpendAnalytics(params) {
     return this.client.get("/billing/spend-analytics", params);
@@ -12548,52 +12598,6 @@ var ToolApprovalGrantsEndpoint = class {
     return this.client.delete(`/tool-approval-grants/${id}`);
   }
 };
-var AppsEndpoint = class {
-  constructor(client) {
-    this.client = client;
-  }
-  /** List apps for the authenticated owner, newest first. */
-  async list() {
-    return this.client.get("/apps");
-  }
-  /** Get an app by id, including its URL and active version pointer. */
-  async get(id) {
-    return this.client.get(`/apps/${id}`);
-  }
-  /** Create an app. A client token scoped to the app origin is auto-provisioned. */
-  async create(data) {
-    return this.client.post("/apps", data);
-  }
-  /** Update name, description, visibility, or status (suspended serves 410). */
-  async update(id, data) {
-    return this.client.patch(`/apps/${id}`, data);
-  }
-  /** Delete an app, its versions, and its hosting. Irreversible. */
-  async delete(id) {
-    return this.client.delete(`/apps/${id}`);
-  }
-  /** List an app's versions, newest first. */
-  async listVersions(id) {
-    return this.client.get(`/apps/${id}/versions`);
-  }
-  /** Upload a zipped bundle (raw application/zip body) as a new version. */
-  async uploadVersion(id, zipBytes) {
-    return this.client.postBinary(`/apps/${id}/versions`, zipBytes, "application/zip");
-  }
-  /**
-   * Upload a bundle from in-memory file maps (the API zips server-side).
-   * Text files in `files`, binary files base64-encoded in `filesBase64`.
-   */
-  async uploadVersionFiles(id, data) {
-    return this.client.post(`/apps/${id}/versions`, data);
-  }
-  /** Activate an uploaded version (deploy or rollback). */
-  async activate(id, versionId) {
-    return this.client.post(`/apps/${id}/activate`, {
-      versionId
-    });
-  }
-};
 
 // src/client.ts
 function isObjectRecord(value) {
@@ -12630,6 +12634,7 @@ var RuntypeClient2 = class {
     this.flows = new FlowsEndpoint(this);
     this.prompts = new PromptsEndpoint(this);
     this.records = new RecordsEndpoint(this);
+    this.collections = new CollectionsEndpoint(this);
     this.apiKeys = new ApiKeysEndpoint(this);
     this.modelConfigs = new ModelConfigsEndpoint(this);
     this.providerKeys = new ProviderKeysEndpoint(this);
@@ -12644,7 +12649,6 @@ var RuntypeClient2 = class {
     this.clientTokens = new ClientTokensEndpoint(this);
     this.agents = new AgentsEndpoint(this);
     this.secrets = new SecretsEndpoint(this);
-    this.apps = new AppsEndpoint(this);
     this.schedules = new SchedulesEndpoint(this);
     this.surfaces = new SurfacesEndpoint(this);
     this.conversations = new ConversationsEndpoint(this);
@@ -13467,6 +13471,7 @@ var FETCH_URL_FIELDS = [
   { key: "markdownIfAvailable", format: "raw" },
   { key: "fetchMethod", format: "json", skipDefault: "standard" },
   { key: "firecrawl", format: "value" },
+  { key: "massive", format: "value" },
   { key: "outputVariable", format: "json" },
   { key: "streamOutput", format: "raw" },
   { key: "errorHandling", format: "value", skipDefault: "fail" },
@@ -13530,7 +13535,10 @@ var SEND_EMAIL_FIELDS = [
   { key: "defaultValue", format: "value" }
 ];
 var SEND_STREAM_FIELDS = [
-  { key: "message", format: "template" }
+  { key: "message", format: "template" },
+  { key: "outputVariable", format: "json" },
+  { key: "errorHandling", format: "value", skipDefault: "fail" },
+  { key: "defaultValue", format: "value" }
 ];
 var RETRIEVE_RECORD_FIELDS = [
   { key: "retrievalMode", format: "json" },
@@ -13542,7 +13550,6 @@ var RETRIEVE_RECORD_FIELDS = [
   { key: "fieldsToExclude", format: "json" },
   { key: "availableFields", format: "value" },
   { key: "outputVariable", format: "json" },
-  { key: "fields", format: "value" },
   { key: "includeMetadata", format: "raw" },
   { key: "streamOutput", format: "raw" }
 ];
@@ -13587,7 +13594,6 @@ var VECTOR_SEARCH_FIELDS = [
   { key: "vectorStore", format: "json" },
   { key: "weaviateConfig", format: "value" },
   { key: "vectorizeConfig", format: "value" },
-  { key: "pineconeConfig", format: "value" },
   { key: "limit", format: "raw", skipDefault: 5 },
   { key: "threshold", format: "raw", skipDefault: 0.7 },
   { key: "metadataFilters", format: "value" },
@@ -13604,7 +13610,6 @@ var GENERATE_EMBEDDING_FIELDS = [
   { key: "recordType", format: "json" },
   { key: "recordName", format: "json" },
   { key: "textField", format: "json" },
-  { key: "storeInRecord", format: "raw" },
   { key: "embeddingModel", format: "json" },
   { key: "maxLength", format: "raw" },
   { key: "inputMode", format: "json" },
@@ -13612,7 +13617,6 @@ var GENERATE_EMBEDDING_FIELDS = [
   { key: "itemAlias", format: "json" },
   { key: "textTemplate", format: "template" },
   { key: "batchSize", format: "raw" },
-  { key: "vectorStore", format: "value" },
   { key: "outputVariable", format: "json" },
   { key: "streamOutput", format: "raw" }
 ];
@@ -13632,31 +13636,9 @@ var SEND_EVENT_FIELDS = [
   { key: "streamOutput", format: "raw" },
   { key: "errorHandling", format: "value", skipDefault: "fail" }
 ];
-var SEND_TEXT_FIELDS = [
-  { key: "to", format: "json" },
-  { key: "from", format: "json" },
-  { key: "message", format: "template" },
-  { key: "outputVariable", format: "json" },
-  { key: "streamOutput", format: "raw" },
-  { key: "errorHandling", format: "value", skipDefault: "fail" }
-];
-var FETCH_GITHUB_FIELDS = [
-  { key: "repository", format: "json" },
-  { key: "branch", format: "json" },
-  { key: "path", format: "json" },
-  { key: "token", format: "json" },
-  { key: "outputVariable", format: "json" },
-  { key: "contentType", format: "json" },
-  { key: "includePatterns", format: "value" },
-  { key: "excludePatterns", format: "value" },
-  { key: "compress", format: "raw" },
-  { key: "style", format: "json" },
-  { key: "streamOutput", format: "raw" }
-];
 var API_CALL_FIELDS = [
   { key: "http", format: "value" },
   { key: "auth", format: "value" },
-  { key: "requestTemplate", format: "template" },
   { key: "responseMapping", format: "value" },
   { key: "outputVariable", format: "json" },
   { key: "streamOutput", format: "raw" },
@@ -13667,7 +13649,6 @@ var EXECUTE_AGENT_FIELDS = [
   { key: "agentId", format: "json" },
   { key: "message", format: "template" },
   { key: "outputVariable", format: "json" },
-  { key: "variables", format: "value" },
   { key: "maxTurns", format: "raw" },
   { key: "timeout", format: "raw" },
   { key: "errorHandling", format: "value", skipDefault: "fail" },
@@ -13714,7 +13695,6 @@ var UPDATE_RECORD_FIELDS = [
   { key: "recordName", format: "json" },
   { key: "recordFilter", format: "value" },
   { key: "updates", format: "value" },
-  { key: "updatesTemplate", format: "template" },
   { key: "mergeStrategy", format: "json" },
   { key: "outputVariable", format: "json" },
   { key: "streamOutput", format: "raw" },
@@ -13751,7 +13731,6 @@ var PAGINATE_API_FIELDS = [
   { key: "startPage", format: "raw" },
   { key: "entitiesPath", format: "json" },
   { key: "entityPath", format: "json" },
-  { key: "entityIdPath", format: "json" },
   { key: "maxEntities", format: "raw" },
   { key: "requestDelayMs", format: "raw" },
   { key: "retryOnRateLimit", format: "raw" },
@@ -13771,13 +13750,10 @@ var STORE_VECTOR_FIELDS = [
   { key: "destination", format: "json" },
   { key: "weaviateConfig", format: "value" },
   { key: "vectorizeConfig", format: "value" },
-  { key: "pineconeConfig", format: "value" },
   { key: "weaviateConfigId", format: "json" },
   { key: "weaviateClassName", format: "json" },
   { key: "vectorizeConfigId", format: "json" },
   { key: "vectorizeNamespace", format: "json" },
-  { key: "pineconeConfigId", format: "json" },
-  { key: "pineconeNamespace", format: "json" },
   { key: "idTemplate", format: "template" },
   { key: "metadata", format: "value" },
   { key: "outputVariable", format: "json" },
@@ -13829,8 +13805,6 @@ var STEP_FIELD_REGISTRY = {
   "generate-embedding": GENERATE_EMBEDDING_FIELDS,
   "wait-until": WAIT_UNTIL_FIELDS,
   "send-event": SEND_EVENT_FIELDS,
-  "send-text": SEND_TEXT_FIELDS,
-  "fetch-github": FETCH_GITHUB_FIELDS,
   template: TEMPLATE_FIELDS,
   "store-asset": STORE_ASSET_FIELDS,
   "generate-pdf": GENERATE_PDF_FIELDS,
@@ -13850,7 +13824,6 @@ var STEP_TYPE_TO_METHOD = {
   "retrieve-record": "retrieveRecord",
   "get-record": "getRecord",
   "list-records": "listRecords",
-  "fetch-github": "fetchGitHub",
   "transform-data": "transformData",
   template: "template",
   conditional: "conditional",
@@ -13858,7 +13831,6 @@ var STEP_TYPE_TO_METHOD = {
   "upsert-record": "upsertRecord",
   "update-record": "updateRecord",
   "send-email": "sendEmail",
-  "send-text": "sendText",
   "send-event": "sendEvent",
   "send-stream": "sendStream",
   search: "search",
@@ -13883,7 +13855,6 @@ export {
   AgentsNamespace,
   AnalyticsEndpoint,
   ApiKeysEndpoint,
-  AppsEndpoint,
   BatchBuilder,
   BatchesNamespace,
   BillingEndpoint,
@@ -13892,6 +13863,7 @@ export {
   ClientEvalBuilder,
   ClientFlowBuilder,
   ClientTokensEndpoint,
+  CollectionsEndpoint,
   ContextTemplatesEndpoint,
   ConversationsEndpoint,
   DEFAULT_RECOVERY_AFTER_EMPTY_SESSIONS,