@runtypelabs/sdk 5.9.0 → 6.1.3

package/dist/index.cjs

@@ -27,7 +27,6 @@ __export(index_exports, {
   AgentsNamespace: () => AgentsNamespace,
   AnalyticsEndpoint: () => AnalyticsEndpoint,
   ApiKeysEndpoint: () => ApiKeysEndpoint,
-  AppsEndpoint: () => AppsEndpoint,
   BatchBuilder: () => BatchBuilder,
   BatchesNamespace: () => BatchesNamespace,
   BillingEndpoint: () => BillingEndpoint,
@@ -36,6 +35,7 @@ __export(index_exports, {
   ClientEvalBuilder: () => ClientEvalBuilder,
   ClientFlowBuilder: () => ClientFlowBuilder,
   ClientTokensEndpoint: () => ClientTokensEndpoint,
+  CollectionsEndpoint: () => CollectionsEndpoint,
   ContextTemplatesEndpoint: () => ContextTemplatesEndpoint,
   ConversationsEndpoint: () => ConversationsEndpoint,
   DEFAULT_RECOVERY_AFTER_EMPTY_SESSIONS: () => DEFAULT_RECOVERY_AFTER_EMPTY_SESSIONS,
@@ -1338,6 +1338,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,
@@ -1473,7 +1474,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
@@ -1498,7 +1502,6 @@ var FlowBuilder = class {
         fieldsToExclude: config.fieldsToExclude,
         availableFields: config.availableFields,
         outputVariable: config.outputVariable,
-        fields: config.fields,
         includeMetadata: config.includeMetadata,
         streamOutput: config.streamOutput
       },
@@ -1591,7 +1594,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,
@@ -1620,7 +1622,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,
@@ -1628,7 +1629,6 @@ var FlowBuilder = class {
         itemAlias: config.itemAlias,
         textTemplate: config.textTemplate,
         batchSize: config.batchSize,
-        vectorStore: config.vectorStore,
         outputVariable: config.outputVariable,
         streamOutput: config.streamOutput
       },
@@ -1677,51 +1677,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);
@@ -2125,6 +2080,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",
@@ -2340,12 +2320,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 }');
@@ -2412,9 +2391,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');
@@ -2463,7 +2448,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);
@@ -2479,9 +2471,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),
@@ -2490,10 +2486,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) {
@@ -2540,11 +2533,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];
@@ -2565,7 +2555,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 : "",
@@ -2577,14 +2567,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([
@@ -2607,27 +2594,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_")) {
@@ -2648,7 +2635,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`)
         );
@@ -2674,7 +2661,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) {
@@ -2689,7 +2676,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) {
@@ -2716,7 +2703,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) {
@@ -2780,7 +2767,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(
@@ -3145,6 +3132,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,
@@ -3305,7 +3293,6 @@ var RuntypeFlowBuilder = class {
         fieldsToExclude: config.fieldsToExclude,
         availableFields: config.availableFields,
         outputVariable: config.outputVariable,
-        fields: config.fields,
         includeMetadata: config.includeMetadata,
         streamOutput: config.streamOutput
       },
@@ -3398,7 +3385,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,
@@ -3427,7 +3413,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,
@@ -3435,7 +3420,6 @@ var RuntypeFlowBuilder = class {
         itemAlias: config.itemAlias,
         textTemplate: config.textTemplate,
         batchSize: config.batchSize,
-        vectorStore: config.vectorStore,
         outputVariable: config.outputVariable,
         streamOutput: config.streamOutput
       },
@@ -3484,51 +3468,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);
@@ -4075,6 +4014,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(
@@ -4088,6 +4051,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
@@ -4261,6 +4273,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
@@ -4295,6 +4331,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
    *
@@ -4413,42 +4471,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) {
@@ -4458,7 +4495,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));
@@ -4468,7 +4505,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) {
@@ -4509,7 +4546,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(
@@ -4858,14 +4895,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];
@@ -4878,7 +4915,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;
@@ -4900,7 +4937,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) => {
@@ -4910,7 +4947,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}`);
     }
@@ -4918,16 +4955,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_")) {
@@ -5001,7 +5038,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(
@@ -5103,27 +5140,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 } : {},
@@ -5132,10 +5151,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",
@@ -5168,10 +5184,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));
@@ -5219,7 +5235,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(
@@ -5339,26 +5355,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 } : {},
@@ -5366,10 +5364,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) {
@@ -5385,7 +5380,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));
@@ -5432,7 +5427,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(
@@ -5513,50 +5508,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)');
   }
@@ -5652,26 +5628,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,
@@ -5680,10 +5638,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",
@@ -5724,13 +5679,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)) {
@@ -5786,7 +5741,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(
@@ -6399,7 +6354,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)`;
 
@@ -8643,6 +8598,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;
@@ -9262,13 +9280,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;
   }
   /**
@@ -12688,6 +12714,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) {
@@ -12706,7 +12748,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);
@@ -12735,52 +12785,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) {
@@ -12817,6 +12821,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);
@@ -12831,7 +12836,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);
@@ -13654,6 +13658,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" },
@@ -13717,7 +13722,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" },
@@ -13729,7 +13737,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" }
 ];
@@ -13774,7 +13781,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" },
@@ -13791,7 +13797,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" },
@@ -13799,7 +13804,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" }
 ];
@@ -13819,31 +13823,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" },
@@ -13854,7 +13836,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" },
@@ -13901,7 +13882,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" },
@@ -13938,7 +13918,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" },
@@ -13958,13 +13937,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" },
@@ -14016,8 +13992,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,
@@ -14037,7 +14011,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",
@@ -14045,7 +14018,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",
@@ -14071,7 +14043,6 @@ var STEP_TYPE_TO_METHOD = {
   AgentsNamespace,
   AnalyticsEndpoint,
   ApiKeysEndpoint,
-  AppsEndpoint,
   BatchBuilder,
   BatchesNamespace,
   BillingEndpoint,
@@ -14080,6 +14051,7 @@ var STEP_TYPE_TO_METHOD = {
   ClientEvalBuilder,
   ClientFlowBuilder,
   ClientTokensEndpoint,
+  CollectionsEndpoint,
   ContextTemplatesEndpoint,
   ConversationsEndpoint,
   DEFAULT_RECOVERY_AFTER_EMPTY_SESSIONS,