@runtypelabs/sdk 5.8.1 → 5.10.0

package/dist/index.mjs

@@ -1938,6 +1938,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",
@@ -2096,12 +2121,16 @@ function judge(criteria, opts) {
   if (typeof criteria !== "string" || criteria.trim().length === 0) {
     throw new Error("judge() requires non-empty criteria");
   }
+  if (opts?.judgeFlowId !== void 0 && opts.judgeFlowId.trim().length === 0) {
+    throw new Error("judge() requires a non-empty judgeFlowId when one is provided");
+  }
   return gradeable({
     kind: "ai",
     criteria,
     ...opts?.preset ? { preset: opts.preset } : {},
     ...opts?.useExpected ? { useExpected: true } : {},
     ...opts?.model ? { model: opts.model } : {},
+    ...opts?.judgeFlowId ? { judgeFlowId: opts.judgeFlowId } : {},
     ...opts?.threshold !== void 0 ? { threshold: opts.threshold } : {}
   });
 }
@@ -2152,9 +2181,6 @@ var DEFINE_EVAL_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "virtual"
 ]);
 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 }');
@@ -2299,10 +2325,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) {
@@ -2349,11 +2372,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];
@@ -2374,7 +2394,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 : "",
@@ -2386,14 +2406,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([
@@ -2416,27 +2433,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_")) {
@@ -2457,7 +2474,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`)
         );
@@ -2483,7 +2500,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) {
@@ -2498,7 +2515,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) {
@@ -2525,7 +2542,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) {
@@ -2589,7 +2606,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(
@@ -3884,6 +3901,18 @@ 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
+    );
+  }
   /** Edit, enable, or disable a test case. */
   async updateCase(suiteId, caseId, input) {
     return this.getClient().patch(
@@ -4070,6 +4099,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
@@ -4222,42 +4275,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) {
@@ -4267,7 +4299,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));
@@ -4277,7 +4309,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) {
@@ -4318,7 +4350,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(
@@ -4667,14 +4699,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];
@@ -4687,7 +4719,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;
@@ -4709,7 +4741,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) => {
@@ -4719,7 +4751,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}`);
     }
@@ -4727,16 +4759,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_")) {
@@ -4810,7 +4842,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(
@@ -4912,27 +4944,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 } : {},
@@ -4941,10 +4955,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",
@@ -4977,10 +4988,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));
@@ -5028,7 +5039,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(
@@ -5148,26 +5159,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 } : {},
@@ -5175,10 +5168,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) {
@@ -5194,7 +5184,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));
@@ -5241,7 +5231,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(
@@ -5322,50 +5312,29 @@ 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) } : {}
   };
 }
 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)');
   }
@@ -5461,26 +5430,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,
@@ -5489,10 +5440,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",
@@ -5533,13 +5481,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)) {
@@ -5595,7 +5543,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(
@@ -6208,7 +6156,7 @@ var Runtype = class {
 
 // src/version.ts
 var FALLBACK_VERSION = "0.0.0";
-var SDK_VERSION = "5.8.1".length > 0 ? "5.8.1" : FALLBACK_VERSION;
+var SDK_VERSION = "5.10.0".length > 0 ? "5.10.0" : FALLBACK_VERSION;
 var RUNTYPE_CLIENT_KIND = "sdk";
 var SDK_USER_AGENT = `runtype-sdk/${SDK_VERSION} (typescript)`;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/sdk",
-  "version": "5.8.1",
+  "version": "5.10.0",
   "type": "module",
   "description": "TypeScript SDK for the Runtype API with fluent methods. Use it to quickly realize AI products, agents, and workflows.",
   "main": "dist/index.cjs",