@runtypelabs/sdk 4.14.0 → 4.16.0

package/dist/index.mjs

@@ -1094,20 +1094,20 @@ var FlowBuilder = class {
    */
   build() {
     const flow = this.existingFlowId ? { id: this.existingFlowId } : { name: this.flowConfig.name, steps: this.steps };
-    const request3 = { flow };
+    const request6 = { flow };
     if (this.recordConfig) {
-      request3.record = this.recordConfig;
+      request6.record = this.recordConfig;
     }
     if (this.messagesConfig) {
-      request3.messages = this.messagesConfig;
+      request6.messages = this.messagesConfig;
     }
     if (this.inputsConfig) {
-      request3.inputs = this.inputsConfig;
+      request6.inputs = this.inputsConfig;
     }
     if (Object.keys(this.optionsConfig).length > 0) {
-      request3.options = this.optionsConfig;
+      request6.options = this.optionsConfig;
     }
-    return request3;
+    return request6;
   }
   /**
    * Validate this prospective flow against the public validation endpoint
@@ -2501,15 +2501,15 @@ var RuntypeFlowBuilder = class {
   build() {
     const flowMode = this.mode === "existing" ? "existing" : this.mode;
     const flow = this.existingFlowId ? { id: this.existingFlowId } : { name: this.flowConfig.name, steps: this.steps };
-    const request3 = { flow };
+    const request6 = { flow };
     if (this.recordConfig) {
-      request3.record = this.recordConfig;
+      request6.record = this.recordConfig;
     }
     if (this.messagesConfig) {
-      request3.messages = this.messagesConfig;
+      request6.messages = this.messagesConfig;
     }
     if (this.inputsConfig) {
-      request3.inputs = this.inputsConfig;
+      request6.inputs = this.inputsConfig;
     }
     const options = {
       flowMode,
@@ -2527,8 +2527,8 @@ var RuntypeFlowBuilder = class {
     if (this.mode === "upsert" && Object.keys(this.upsertOptions).length > 0) {
       options.upsertOptions = this.upsertOptions;
     }
-    request3.options = options;
-    return request3;
+    request6.options = options;
+    return request6;
   }
   /**
    * Validate this prospective flow against the public validation endpoint
@@ -3122,6 +3122,192 @@ var PromptsNamespace = class {
   }
 };
 
+// src/skills-ensure.ts
+function isPlainObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeValue(item));
+  }
+  if (isPlainObject2(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 = isPlainObject2(definition.manifest) ? definition.manifest : {};
+  const rawFrontmatter = isPlainObject2(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 = isPlainObject2(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("");
+}
+var DEFINE_SKILL_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set(["name", "manifest"]);
+function defineSkill(input) {
+  if (!input || typeof input !== "object") {
+    throw new Error("defineSkill requires a definition object");
+  }
+  if (typeof input.name !== "string" || input.name.length === 0) {
+    throw new Error('defineSkill requires a non-empty string "name"');
+  }
+  if (!isPlainObject2(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));
+  if (unknownKeys.length > 0) {
+    throw new Error(
+      `defineSkill: unknown field(s): ${unknownKeys.join(", ")}. Allowed fields are name and manifest.`
+    );
+  }
+  const frontmatter = input.manifest.frontmatter;
+  if (!isPlainObject2(frontmatter) || typeof frontmatter.name !== "string") {
+    throw new Error("defineSkill: manifest.frontmatter.name is required");
+  }
+  if (frontmatter.name !== input.name) {
+    throw new Error(
+      `defineSkill: manifest.frontmatter.name ("${frontmatter.name}") must match the identity name ("${input.name}").`
+    );
+  }
+  return { name: input.name, manifest: input.manifest };
+}
+var SkillEnsureConflictError = class extends Error {
+  constructor(body) {
+    super(body.error ?? `Skill ensure conflict: ${body.code}`);
+    this.name = "SkillEnsureConflictError";
+    this.code = body.code;
+    this.lastModifiedSource = body.lastModifiedSource;
+    this.modifiedAt = body.modifiedAt;
+    this.currentHash = body.currentHash;
+  }
+};
+var SkillDriftError = class extends Error {
+  constructor(plan) {
+    super(
+      `Skill "${plan.skillId ?? "definition"}" drifted: plan is '${plan.changes}' (changed: ${plan.changedKeys.join(", ") || "n/a"}). Run client.skills.pull(name) to absorb the remote edit into your repo, or re-run ensure to converge.`
+    );
+    this.name = "SkillDriftError";
+    this.plan = plan;
+  }
+};
+function parseRequestError2(err) {
+  if (!(err instanceof Error)) return { status: null, body: null };
+  const match = err.message.match(/^API request failed: (\d{3}) .*? - ([\s\S]*)$/);
+  if (!match) return { status: null, body: null };
+  try {
+    return { status: Number(match[1]), body: JSON.parse(match[2]) };
+  } catch {
+    return { status: Number(match[1]), body: null };
+  }
+}
+function toConflictError2(err) {
+  const { status, body } = parseRequestError2(err);
+  if (status !== 409 || !isPlainObject2(body)) return null;
+  const code = body.code;
+  if (code !== "external_modification" && code !== "remote_changed") return null;
+  return new SkillEnsureConflictError(
+    body
+  );
+}
+var serverHashMemo2 = /* @__PURE__ */ new WeakMap();
+function memoFor2(client) {
+  let memo = serverHashMemo2.get(client);
+  if (!memo) {
+    memo = /* @__PURE__ */ new Map();
+    serverHashMemo2.set(client, memo);
+  }
+  return memo;
+}
+function memoize2(memo, memoKey, result) {
+  if (result.result !== "plan") memo.set(memoKey, result.contentHash);
+}
+async function request2(client, body) {
+  try {
+    return await client.post(
+      "/skills/ensure",
+      body
+    );
+  } catch (err) {
+    const conflict = toConflictError2(err);
+    if (conflict) throw conflict;
+    throw err;
+  }
+}
+async function ensureSkill(client, definition, options = {}) {
+  const { dryRun, onConflict, release, expectedRemoteHash, expectNoChanges } = options;
+  const passthrough = {
+    ...onConflict ? { onConflict } : {},
+    ...release ? { release } : {},
+    ...expectedRemoteHash ? { expectedRemoteHash } : {}
+  };
+  if (dryRun || expectNoChanges) {
+    const plan = await request2(client, {
+      name: definition.name,
+      definition: manifestToWire(definition),
+      dryRun: true,
+      ...passthrough
+    });
+    if (plan.result !== "plan") {
+      throw new Error(`Expected a plan result from dryRun, got '${plan.result}'`);
+    }
+    if (expectNoChanges && plan.changes !== "none") {
+      throw new SkillDriftError(plan);
+    }
+    return plan;
+  }
+  const memo = memoFor2(client);
+  const localHash = await computeSkillContentHash(definition);
+  const memoKey = `${definition.name} ${localHash}`;
+  const contentHash = memo.get(memoKey) ?? localHash;
+  const probe = await request2(client, {
+    name: definition.name,
+    contentHash,
+    ...passthrough
+  });
+  if (probe.result !== "definitionRequired") {
+    memoize2(memo, memoKey, probe);
+    return probe;
+  }
+  const converged = await request2(client, {
+    name: definition.name,
+    definition: manifestToWire(definition),
+    ...passthrough
+  });
+  if (converged.result === "definitionRequired") {
+    throw new Error("Server reported definitionRequired for a full-definition request");
+  }
+  memoize2(memo, memoKey, converged);
+  return converged;
+}
+function manifestToWire(definition) {
+  const manifest = definition.manifest;
+  const frontmatter = { ...manifest.frontmatter };
+  if (manifest.runtype && Object.keys(manifest.runtype).length > 0) {
+    frontmatter.runtype = manifest.runtype;
+  }
+  return { frontmatter, body: manifest.body ?? "" };
+}
+async function pullSkill(client, name) {
+  return client.get("/skills/pull", { name });
+}
+
 // src/skills-namespace.ts
 var SkillProposalsNamespace = class {
   constructor(getClient) {
@@ -3262,6 +3448,22 @@ var SkillsNamespace = class {
     const client = this.getClient();
     await client.post(`/skills/${skillId}/versions/${versionId}/publish`);
   }
+  /**
+   * Statically scan a SKILL.md document for malicious patterns and return a
+   * two-tier verdict — `warning` when a skill appears suspicious (low–medium
+   * confidence), `error` when high-confidence malicious. Does not persist or
+   * gate; use it as a "scan before save" affordance.
+   *
+   * @example
+   * ```typescript
+   * const { verdict } = await Runtype.skills.scan(skillMarkdown)
+   * if (verdict.tier === 'error') console.warn(verdict.summary)
+   * ```
+   */
+  async scan(markdown) {
+    const client = this.getClient();
+    return client.post("/skills/scan", { markdown });
+  }
   /**
    * Import a single SKILL.md document. The imported skill lands with
    * `trustLevel: 'imported'` and a draft version.
@@ -3304,6 +3506,40 @@ var SkillsNamespace = class {
     const res = await client.get("/skills/bindings", { agentId });
     return res.data;
   }
+  /**
+   * Idempotently converge a `defineSkill` definition onto the platform.
+   * Hash-first: the steady state is one tiny probe request. Creates or appends a
+   * new version; never deletes. Identity is name + account scope. Pass
+   * `release: 'publish'` to publish the converged version.
+   *
+   * @example
+   * ```typescript
+   * const reviewer = defineSkill({
+   *   name: 'code_reviewer',
+   *   manifest: {
+   *     frontmatter: { name: 'code_reviewer', description: 'Reviews pull requests' },
+   *     runtype: { trustLevel: 'org' },
+   *     body: '# Code Reviewer\n\nReview the diff...',
+   *   },
+   * })
+   *
+   * // Converge + publish (CI/deploy).
+   * const result = await Runtype.skills.ensure(reviewer, { release: 'publish' })
+   *
+   * // PR drift gate.
+   * await Runtype.skills.ensure(reviewer, { expectNoChanges: true })
+   * ```
+   */
+  async ensure(definition, options = {}) {
+    return ensureSkill(this.getClient(), definition, options);
+  }
+  /**
+   * Pull the canonical definition + provenance for a skill by name — the
+   * absorb-drift direction of the ensure protocol.
+   */
+  async pull(name) {
+    return pullSkill(this.getClient(), name);
+  }
 };
 
 // src/agents-namespace.ts
@@ -3329,19 +3565,19 @@ var AGENT_CONFIG_KEYS = [
   "memory"
 ];
 var AGENT_CONFIG_KEY_LIST = [...AGENT_CONFIG_KEYS].sort();
-function isPlainObject2(value) {
+function isPlainObject3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function normalizeValue(value) {
+function normalizeValue2(value) {
   if (Array.isArray(value)) {
-    return value.map((item) => normalizeValue(item));
+    return value.map((item) => normalizeValue2(item));
   }
-  if (isPlainObject2(value)) {
+  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);
+      normalized[key] = normalizeValue2(entry);
     }
     return normalized;
   }
@@ -3349,11 +3585,11 @@ function normalizeValue(value) {
 }
 function normalizeAgentDefinition(definition) {
   const config = {};
-  const rawConfig = isPlainObject2(definition.config) ? definition.config : {};
+  const rawConfig = isPlainObject3(definition.config) ? definition.config : {};
   for (const key of AGENT_CONFIG_KEY_LIST) {
     const value = rawConfig[key];
     if (value === void 0 || value === null) continue;
-    config[key] = normalizeValue(value);
+    config[key] = normalizeValue2(value);
   }
   return {
     name: definition.name,
@@ -3371,7 +3607,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 (!isPlainObject2(tools)) return [];
+  if (!isPlainObject3(tools)) return [];
   const found = [];
   const isAccountScoped = (ref) => typeof ref === "string" && ref.startsWith("tool_");
   const scanArray = (value, path) => {
@@ -3381,7 +3617,7 @@ function collectNonPortableToolRefs(config) {
     });
   };
   const scanKeys = (value, path) => {
-    if (!isPlainObject2(value)) return;
+    if (!isPlainObject3(value)) return;
     for (const key of Object.keys(value)) {
       if (isAccountScoped(key)) found.push(`${path}.${key}`);
     }
@@ -3389,16 +3625,16 @@ function collectNonPortableToolRefs(config) {
   scanArray(tools.toolIds, "tools.toolIds");
   scanKeys(tools.toolConfigs, "tools.toolConfigs");
   scanKeys(tools.perToolLimits, "tools.perToolLimits");
-  if (isPlainObject2(tools.approval)) scanArray(tools.approval.require, "tools.approval.require");
-  if (isPlainObject2(tools.subagentConfig)) {
+  if (isPlainObject3(tools.approval)) scanArray(tools.approval.require, "tools.approval.require");
+  if (isPlainObject3(tools.subagentConfig)) {
     scanArray(tools.subagentConfig.toolPool, "tools.subagentConfig.toolPool");
   }
-  if (isPlainObject2(tools.codeModeConfig)) {
+  if (isPlainObject3(tools.codeModeConfig)) {
     scanArray(tools.codeModeConfig.toolPool, "tools.codeModeConfig.toolPool");
   }
   if (Array.isArray(tools.runtimeTools)) {
     tools.runtimeTools.forEach((runtimeTool, i) => {
-      if (!isPlainObject2(runtimeTool) || !isPlainObject2(runtimeTool.config)) return;
+      if (!isPlainObject3(runtimeTool) || !isPlainObject3(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_")) {
@@ -3459,226 +3695,693 @@ var AgentDriftError = class extends Error {
     this.name = "AgentDriftError";
     this.plan = plan;
   }
-};
-function parseRequestError2(err) {
-  if (!(err instanceof Error)) return { status: null, body: null };
-  const match = err.message.match(/^API request failed: (\d{3}) .*? - ([\s\S]*)$/);
-  if (!match) return { status: null, body: null };
-  try {
-    return { status: Number(match[1]), body: JSON.parse(match[2]) };
-  } catch {
-    return { status: Number(match[1]), body: null };
+};
+function parseRequestError3(err) {
+  if (!(err instanceof Error)) return { status: null, body: null };
+  const match = err.message.match(/^API request failed: (\d{3}) .*? - ([\s\S]*)$/);
+  if (!match) return { status: null, body: null };
+  try {
+    return { status: Number(match[1]), body: JSON.parse(match[2]) };
+  } catch {
+    return { status: Number(match[1]), body: null };
+  }
+}
+function toConflictError3(err) {
+  const { status, body } = parseRequestError3(err);
+  if (status !== 409 || !isPlainObject3(body)) return null;
+  const code = body.code;
+  if (code !== "external_modification" && code !== "remote_changed") return null;
+  return new AgentEnsureConflictError(
+    body
+  );
+}
+var serverHashMemo3 = /* @__PURE__ */ new WeakMap();
+function memoFor3(client) {
+  let memo = serverHashMemo3.get(client);
+  if (!memo) {
+    memo = /* @__PURE__ */ new Map();
+    serverHashMemo3.set(client, memo);
+  }
+  return memo;
+}
+var AgentsNamespace = class {
+  constructor(getClient) {
+    this.getClient = getClient;
+  }
+  /**
+   * Idempotently converge a definition onto the platform. Hash-first: probes
+   * with a content hash, and only ships the full definition when the server
+   * reports a miss (`definitionRequired`). Creates an immutable version
+   * snapshot on every change; never deletes.
+   */
+  async ensure(definition, options = {}) {
+    const client = this.getClient();
+    const { dryRun, onConflict, release, expectedRemoteHash, expectNoChanges } = options;
+    const passthrough = {
+      ...onConflict ? { onConflict } : {},
+      ...release ? { release } : {},
+      ...expectedRemoteHash ? { expectedRemoteHash } : {}
+    };
+    if (dryRun || expectNoChanges) {
+      const plan = await this.request(client, {
+        name: definition.name,
+        definition,
+        dryRun: true,
+        ...passthrough
+      });
+      if (plan.result !== "plan") {
+        throw new Error(`Expected a plan result from dryRun, got '${plan.result}'`);
+      }
+      if (expectNoChanges && plan.changes !== "none") {
+        throw new AgentDriftError(plan);
+      }
+      return plan;
+    }
+    const memo = memoFor3(client);
+    const localHash = await computeAgentContentHash({
+      ...definition,
+      config: definition.config
+    });
+    const memoKey = `${definition.name}\0${localHash}`;
+    const contentHash = memo.get(memoKey) ?? localHash;
+    const probe = await this.request(client, {
+      name: definition.name,
+      contentHash,
+      ...passthrough
+    });
+    if (probe.result !== "definitionRequired") {
+      this.memoize(memo, memoKey, probe);
+      return probe;
+    }
+    const converged = await this.request(client, {
+      name: definition.name,
+      definition,
+      ...passthrough
+    });
+    if (converged.result === "definitionRequired") {
+      throw new Error("Server reported definitionRequired for a full-definition request");
+    }
+    this.memoize(memo, memoKey, converged);
+    return converged;
+  }
+  /**
+   * Pull the canonical definition + provenance for an agent by name — the
+   * absorb-drift direction. The contentHash reflects the live agent state.
+   */
+  async pull(name) {
+    const client = this.getClient();
+    return client.get("/agents/pull", { name });
+  }
+  memoize(memo, memoKey, result) {
+    if (result.result !== "plan") memo.set(memoKey, result.contentHash);
+  }
+  async request(client, body) {
+    try {
+      return await client.post(
+        "/agents/ensure",
+        body
+      );
+    } catch (err) {
+      const conflict = toConflictError3(err);
+      if (conflict) throw conflict;
+      throw err;
+    }
+  }
+};
+
+// src/tools-ensure.ts
+function isPlainObject4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeValue3(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeValue3(item));
+  }
+  if (isPlainObject4(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 = isPlainObject4(definition.parametersSchema) ? normalizeValue3(definition.parametersSchema) : {};
+  const config = isPlainObject4(definition.config) ? normalizeValue3(definition.config) : {};
+  return {
+    toolType: definition.toolType,
+    ...definition.description ? { description: definition.description } : {},
+    parametersSchema,
+    config
+  };
+}
+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("");
+}
+var DEFINE_TOOL_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "toolType",
+  "parametersSchema",
+  "config"
+]);
+var TOOL_DEFINITION_TYPES = /* @__PURE__ */ new Set([
+  "flow",
+  "custom",
+  "external",
+  "graphql",
+  "mcp",
+  "local",
+  "subagent"
+]);
+function defineTool(input) {
+  if (!input || typeof input !== "object") {
+    throw new Error("defineTool requires a definition object");
+  }
+  if (typeof input.name !== "string" || input.name.length === 0) {
+    throw new Error('defineTool requires a non-empty string "name"');
+  }
+  if (typeof input.description !== "string" || input.description.length === 0) {
+    throw new Error('defineTool requires a non-empty string "description"');
+  }
+  if (typeof input.toolType !== "string" || !TOOL_DEFINITION_TYPES.has(input.toolType)) {
+    throw new Error(
+      `defineTool requires "toolType" to be one of: ${[...TOOL_DEFINITION_TYPES].join(", ")}`
+    );
+  }
+  if (!isPlainObject4(input.parametersSchema)) {
+    throw new Error('defineTool requires a "parametersSchema" object (a JSON Schema)');
+  }
+  if (!isPlainObject4(input.config)) {
+    throw new Error('defineTool requires a "config" object');
+  }
+  const unknownKeys = Object.keys(input).filter((key) => !DEFINE_TOOL_TOP_LEVEL_KEYS.has(key));
+  if (unknownKeys.length > 0) {
+    throw new Error(
+      `defineTool: unknown field(s): ${unknownKeys.join(", ")}. Allowed fields are name, description, toolType, parametersSchema, config.`
+    );
+  }
+  return {
+    name: input.name,
+    description: input.description,
+    toolType: input.toolType,
+    parametersSchema: input.parametersSchema,
+    config: input.config
+  };
+}
+var ToolEnsureConflictError = class extends Error {
+  constructor(body) {
+    super(body.error ?? `Tool ensure conflict: ${body.code}`);
+    this.name = "ToolEnsureConflictError";
+    this.code = body.code;
+    this.lastModifiedSource = body.lastModifiedSource;
+    this.modifiedAt = body.modifiedAt;
+    this.currentHash = body.currentHash;
+  }
+};
+var ToolDriftError = class extends Error {
+  constructor(plan) {
+    super(
+      `Tool "${plan.toolId ?? "definition"}" drifted: plan is '${plan.changes}' (changed: ${plan.changedKeys.join(", ") || "n/a"}). Run client.tools.pull(name) to absorb the remote edit into your repo, or re-run ensure to converge.`
+    );
+    this.name = "ToolDriftError";
+    this.plan = plan;
+  }
+};
+function parseRequestError4(err) {
+  if (!(err instanceof Error)) return { status: null, body: null };
+  const match = err.message.match(/^API request failed: (\d{3}) .*? - ([\s\S]*)$/);
+  if (!match) return { status: null, body: null };
+  try {
+    return { status: Number(match[1]), body: JSON.parse(match[2]) };
+  } catch {
+    return { status: Number(match[1]), body: null };
+  }
+}
+function toConflictError4(err) {
+  const { status, body } = parseRequestError4(err);
+  if (status !== 409 || !isPlainObject4(body)) return null;
+  const code = body.code;
+  if (code !== "external_modification" && code !== "remote_changed") return null;
+  return new ToolEnsureConflictError(
+    body
+  );
+}
+var serverHashMemo4 = /* @__PURE__ */ new WeakMap();
+function memoFor4(client) {
+  let memo = serverHashMemo4.get(client);
+  if (!memo) {
+    memo = /* @__PURE__ */ new Map();
+    serverHashMemo4.set(client, memo);
+  }
+  return memo;
+}
+function memoize3(memo, memoKey, result) {
+  if (result.result !== "plan") memo.set(memoKey, result.contentHash);
+}
+async function request3(client, body) {
+  try {
+    return await client.post(
+      "/tools/ensure",
+      body
+    );
+  } catch (err) {
+    const conflict = toConflictError4(err);
+    if (conflict) throw conflict;
+    throw err;
+  }
+}
+async function ensureTool(client, definition, options = {}) {
+  const { dryRun, onConflict, expectedRemoteHash, expectNoChanges } = options;
+  const passthrough = {
+    ...onConflict ? { onConflict } : {},
+    ...expectedRemoteHash ? { expectedRemoteHash } : {}
+  };
+  if (dryRun || expectNoChanges) {
+    const plan = await request3(client, {
+      name: definition.name,
+      definition,
+      dryRun: true,
+      ...passthrough
+    });
+    if (plan.result !== "plan") {
+      throw new Error(`Expected a plan result from dryRun, got '${plan.result}'`);
+    }
+    if (expectNoChanges && plan.changes !== "none") {
+      throw new ToolDriftError(plan);
+    }
+    return plan;
+  }
+  const memo = memoFor4(client);
+  const localHash = await computeToolContentHash(definition);
+  const memoKey = `${definition.name} ${localHash}`;
+  const contentHash = memo.get(memoKey) ?? localHash;
+  const probe = await request3(client, {
+    name: definition.name,
+    contentHash,
+    ...passthrough
+  });
+  if (probe.result !== "definitionRequired") {
+    memoize3(memo, memoKey, probe);
+    return probe;
+  }
+  const converged = await request3(client, {
+    name: definition.name,
+    definition,
+    ...passthrough
+  });
+  if (converged.result === "definitionRequired") {
+    throw new Error("Server reported definitionRequired for a full-definition request");
+  }
+  memoize3(memo, memoKey, converged);
+  return converged;
+}
+async function pullTool(client, name) {
+  return client.get("/tools/pull", { name });
+}
+
+// src/tools-namespace.ts
+var ToolsNamespace = class {
+  constructor(getClient) {
+    this.getClient = getClient;
+  }
+  /**
+   * Idempotently converge a `defineTool` definition onto the platform.
+   * Hash-first: the steady state is one tiny probe request. Creates or updates
+   * the saved tool; never deletes. Identity is name + account scope.
+   *
+   * @example
+   * ```typescript
+   * const weather = defineTool({
+   *   name: 'Weather Lookup',
+   *   description: 'Fetch the current weather for a city',
+   *   toolType: 'external',
+   *   parametersSchema: { type: 'object', properties: { city: { type: 'string' } } },
+   *   config: { url: 'https://api.example.com/weather', method: 'GET' },
+   * })
+   *
+   * // Converge (CI/deploy).
+   * const result = await Runtype.tools.ensure(weather)
+   *
+   * // PR drift gate.
+   * await Runtype.tools.ensure(weather, { expectNoChanges: true })
+   * ```
+   */
+  async ensure(definition, options = {}) {
+    return ensureTool(this.getClient(), definition, options);
+  }
+  /**
+   * Pull the canonical definition + provenance for a tool by name — the
+   * absorb-drift direction of the ensure protocol.
+   */
+  async pull(name) {
+    return pullTool(this.getClient(), name);
+  }
+};
+
+// src/products-ensure.ts
+function isPlainObject5(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeValue4(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeValue4(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] = normalizeValue4(entry);
+    }
+    return normalized;
+  }
+  return value;
+}
+function normalizeProductDefinition(definition) {
+  const spec = isPlainObject5(definition.spec) ? normalizeValue4(definition.spec) : {};
+  return {
+    ...definition.description ? { description: definition.description } : {},
+    ...definition.icon ? { icon: definition.icon } : {},
+    spec
+  };
+}
+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("");
+}
+var DEFINE_PRODUCT_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set(["name", "description", "icon", "spec"]);
+function defineProduct(input) {
+  if (!input || typeof input !== "object") {
+    throw new Error("defineProduct requires a definition object");
+  }
+  if (typeof input.name !== "string" || input.name.length === 0) {
+    throw new Error('defineProduct requires a non-empty string "name"');
+  }
+  if (input.description != null && typeof input.description !== "string") {
+    throw new Error('defineProduct "description" must be a string when provided');
+  }
+  if (input.icon != null && typeof input.icon !== "string") {
+    throw new Error('defineProduct "icon" must be a string when provided');
+  }
+  if (input.spec != null && !isPlainObject5(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));
+  if (unknownKeys.length > 0) {
+    throw new Error(
+      `defineProduct: unknown field(s): ${unknownKeys.join(", ")}. Allowed fields are name, description, icon, spec. (canvas / nested capabilities and surfaces are not converged by ensure.)`
+    );
+  }
+  return {
+    name: input.name,
+    ...input.description !== void 0 ? { description: input.description } : {},
+    ...input.icon !== void 0 ? { icon: input.icon } : {},
+    ...input.spec !== void 0 ? { spec: input.spec } : {}
+  };
+}
+var ProductEnsureConflictError = class extends Error {
+  constructor(body) {
+    super(body.error ?? `Product ensure conflict: ${body.code}`);
+    this.name = "ProductEnsureConflictError";
+    this.code = body.code;
+    this.lastModifiedSource = body.lastModifiedSource;
+    this.modifiedAt = body.modifiedAt;
+    this.currentHash = body.currentHash;
+  }
+};
+var ProductDriftError = class extends Error {
+  constructor(plan) {
+    super(
+      `Product "${plan.productId ?? "definition"}" drifted: plan is '${plan.changes}' (changed: ${plan.changedKeys.join(", ") || "n/a"}). Run client.products.pull(name) to absorb the remote edit into your repo, or re-run ensure to converge.`
+    );
+    this.name = "ProductDriftError";
+    this.plan = plan;
+  }
+};
+function parseRequestError5(err) {
+  if (!(err instanceof Error)) return { status: null, body: null };
+  const match = err.message.match(/^API request failed: (\d{3}) .*? - ([\s\S]*)$/);
+  if (!match) return { status: null, body: null };
+  try {
+    return { status: Number(match[1]), body: JSON.parse(match[2]) };
+  } catch {
+    return { status: Number(match[1]), body: null };
+  }
+}
+function toConflictError5(err) {
+  const { status, body } = parseRequestError5(err);
+  if (status !== 409 || !isPlainObject5(body)) return null;
+  const code = body.code;
+  if (code !== "external_modification" && code !== "remote_changed") return null;
+  return new ProductEnsureConflictError(
+    body
+  );
+}
+var serverHashMemo5 = /* @__PURE__ */ new WeakMap();
+function memoFor5(client) {
+  let memo = serverHashMemo5.get(client);
+  if (!memo) {
+    memo = /* @__PURE__ */ new Map();
+    serverHashMemo5.set(client, memo);
+  }
+  return memo;
+}
+function memoize4(memo, memoKey, result) {
+  if (result.result !== "plan") memo.set(memoKey, result.contentHash);
+}
+async function request4(client, body) {
+  try {
+    return await client.post(
+      "/products/ensure",
+      body
+    );
+  } catch (err) {
+    const conflict = toConflictError5(err);
+    if (conflict) throw conflict;
+    throw err;
+  }
+}
+async function ensureProduct(client, definition, options = {}) {
+  const { dryRun, onConflict, expectedRemoteHash, expectNoChanges } = options;
+  const passthrough = {
+    ...onConflict ? { onConflict } : {},
+    ...expectedRemoteHash ? { expectedRemoteHash } : {}
+  };
+  if (dryRun || expectNoChanges) {
+    const plan = await request4(client, {
+      name: definition.name,
+      definition,
+      dryRun: true,
+      ...passthrough
+    });
+    if (plan.result !== "plan") {
+      throw new Error(`Expected a plan result from dryRun, got '${plan.result}'`);
+    }
+    if (expectNoChanges && plan.changes !== "none") {
+      throw new ProductDriftError(plan);
+    }
+    return plan;
+  }
+  const memo = memoFor5(client);
+  const localHash = await computeProductContentHash(definition);
+  const memoKey = `${definition.name} ${localHash}`;
+  const contentHash = memo.get(memoKey) ?? localHash;
+  const probe = await request4(client, {
+    name: definition.name,
+    contentHash,
+    ...passthrough
+  });
+  if (probe.result !== "definitionRequired") {
+    memoize4(memo, memoKey, probe);
+    return probe;
+  }
+  const converged = await request4(client, {
+    name: definition.name,
+    definition,
+    ...passthrough
+  });
+  if (converged.result === "definitionRequired") {
+    throw new Error("Server reported definitionRequired for a full-definition request");
   }
+  memoize4(memo, memoKey, converged);
+  return converged;
 }
-function toConflictError2(err) {
-  const { status, body } = parseRequestError2(err);
-  if (status !== 409 || !isPlainObject2(body)) return null;
-  const code = body.code;
-  if (code !== "external_modification" && code !== "remote_changed") return null;
-  return new AgentEnsureConflictError(
-    body
-  );
-}
-var serverHashMemo2 = /* @__PURE__ */ new WeakMap();
-function memoFor2(client) {
-  let memo = serverHashMemo2.get(client);
-  if (!memo) {
-    memo = /* @__PURE__ */ new Map();
-    serverHashMemo2.set(client, memo);
-  }
-  return memo;
+async function pullProduct(client, name) {
+  return client.get("/products/pull", { name });
 }
-var AgentsNamespace = class {
+
+// src/products-namespace.ts
+var ProductsNamespace = class {
   constructor(getClient) {
     this.getClient = getClient;
   }
   /**
-   * Idempotently converge a definition onto the platform. Hash-first: probes
-   * with a content hash, and only ships the full definition when the server
-   * reports a miss (`definitionRequired`). Creates an immutable version
-   * snapshot on every change; never deletes.
+   * Idempotently converge a `defineProduct` definition onto the platform.
+   * Hash-first: the steady state is one tiny probe request. Creates or updates
+   * the top-level product record; never deletes. Identity is name + account
+   * scope.
+   *
+   * @example
+   * ```typescript
+   * const product = defineProduct({
+   *   name: 'Support Copilot',
+   *   description: 'An AI support assistant',
+   *   icon: '🤖',
+   *   spec: { productGoal: 'Deflect tier-1 tickets', productStage: 'beta' },
+   * })
+   *
+   * // Converge (CI/deploy).
+   * const result = await Runtype.products.ensure(product)
+   *
+   * // PR drift gate.
+   * await Runtype.products.ensure(product, { expectNoChanges: true })
+   * ```
    */
   async ensure(definition, options = {}) {
-    const client = this.getClient();
-    const { dryRun, onConflict, release, expectedRemoteHash, expectNoChanges } = options;
-    const passthrough = {
-      ...onConflict ? { onConflict } : {},
-      ...release ? { release } : {},
-      ...expectedRemoteHash ? { expectedRemoteHash } : {}
-    };
-    if (dryRun || expectNoChanges) {
-      const plan = await this.request(client, {
-        name: definition.name,
-        definition,
-        dryRun: true,
-        ...passthrough
-      });
-      if (plan.result !== "plan") {
-        throw new Error(`Expected a plan result from dryRun, got '${plan.result}'`);
-      }
-      if (expectNoChanges && plan.changes !== "none") {
-        throw new AgentDriftError(plan);
-      }
-      return plan;
-    }
-    const memo = memoFor2(client);
-    const localHash = await computeAgentContentHash({
-      ...definition,
-      config: definition.config
-    });
-    const memoKey = `${definition.name}\0${localHash}`;
-    const contentHash = memo.get(memoKey) ?? localHash;
-    const probe = await this.request(client, {
-      name: definition.name,
-      contentHash,
-      ...passthrough
-    });
-    if (probe.result !== "definitionRequired") {
-      this.memoize(memo, memoKey, probe);
-      return probe;
-    }
-    const converged = await this.request(client, {
-      name: definition.name,
-      definition,
-      ...passthrough
-    });
-    if (converged.result === "definitionRequired") {
-      throw new Error("Server reported definitionRequired for a full-definition request");
-    }
-    this.memoize(memo, memoKey, converged);
-    return converged;
+    return ensureProduct(this.getClient(), definition, options);
   }
   /**
-   * Pull the canonical definition + provenance for an agent by name — the
-   * absorb-drift direction. The contentHash reflects the live agent state.
+   * Pull the canonical definition + provenance for a product by name — the
+   * absorb-drift direction of the ensure protocol.
    */
   async pull(name) {
-    const client = this.getClient();
-    return client.get("/agents/pull", { name });
-  }
-  memoize(memo, memoKey, result) {
-    if (result.result !== "plan") memo.set(memoKey, result.contentHash);
-  }
-  async request(client, body) {
-    try {
-      return await client.post(
-        "/agents/ensure",
-        body
-      );
-    } catch (err) {
-      const conflict = toConflictError2(err);
-      if (conflict) throw conflict;
-      throw err;
-    }
+    return pullProduct(this.getClient(), name);
   }
 };
 
-// src/tools-ensure.ts
-function isPlainObject3(value) {
+// src/surfaces-ensure.ts
+function isPlainObject6(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function normalizeValue2(value) {
+function normalizeValue5(value) {
   if (Array.isArray(value)) {
-    return value.map((item) => normalizeValue2(item));
+    return value.map((item) => normalizeValue5(item));
   }
-  if (isPlainObject3(value)) {
+  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] = normalizeValue2(entry);
+      normalized[key] = normalizeValue5(entry);
     }
     return normalized;
   }
   return value;
 }
-function normalizeToolDefinition(definition) {
-  const parametersSchema = isPlainObject3(definition.parametersSchema) ? normalizeValue2(definition.parametersSchema) : {};
-  const config = isPlainObject3(definition.config) ? normalizeValue2(definition.config) : {};
+function normalizeSurfaceDefinition(definition) {
+  const behavior = isPlainObject6(definition.behavior) ? normalizeValue5(definition.behavior) : { type: definition.type };
   return {
-    toolType: definition.toolType,
-    ...definition.description ? { description: definition.description } : {},
-    parametersSchema,
-    config
+    type: definition.type,
+    behavior,
+    status: definition.status || "draft",
+    environment: definition.environment || "development"
   };
 }
-async function computeToolContentHash(definition) {
-  const serialized = JSON.stringify(normalizeToolDefinition(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("");
 }
-var DEFINE_TOOL_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
+var DEFINE_SURFACE_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "name",
-  "description",
-  "toolType",
-  "parametersSchema",
-  "config"
+  "type",
+  "behavior",
+  "inbound",
+  "outbound",
+  "status",
+  "environment"
 ]);
-var TOOL_DEFINITION_TYPES = /* @__PURE__ */ new Set([
-  "flow",
-  "custom",
-  "external",
-  "graphql",
+var SURFACE_DEFINITION_TYPES = /* @__PURE__ */ new Set([
+  "chat",
   "mcp",
-  "local",
-  "subagent"
+  "mcp_code",
+  "api",
+  "webhook",
+  "schedule",
+  "a2a",
+  "email",
+  "slack",
+  "sms",
+  "imessage",
+  "discord",
+  "whatsapp",
+  "telegram",
+  "hosted-page",
+  "chrome_extension"
 ]);
-function defineTool(input) {
+function defineSurface(input) {
   if (!input || typeof input !== "object") {
-    throw new Error("defineTool requires a definition object");
+    throw new Error("defineSurface requires a definition object");
   }
   if (typeof input.name !== "string" || input.name.length === 0) {
-    throw new Error('defineTool requires a non-empty string "name"');
+    throw new Error('defineSurface requires a non-empty string "name"');
   }
-  if (typeof input.description !== "string" || input.description.length === 0) {
-    throw new Error('defineTool requires a non-empty string "description"');
-  }
-  if (typeof input.toolType !== "string" || !TOOL_DEFINITION_TYPES.has(input.toolType)) {
+  if (typeof input.type !== "string" || !SURFACE_DEFINITION_TYPES.has(input.type)) {
     throw new Error(
-      `defineTool requires "toolType" to be one of: ${[...TOOL_DEFINITION_TYPES].join(", ")}`
+      `defineSurface requires "type" to be one of: ${[...SURFACE_DEFINITION_TYPES].join(", ")}`
     );
   }
-  if (!isPlainObject3(input.parametersSchema)) {
-    throw new Error('defineTool requires a "parametersSchema" object (a JSON Schema)');
+  if (input.behavior !== void 0 && !isPlainObject6(input.behavior)) {
+    throw new Error('defineSurface "behavior" must be an object when provided');
   }
-  if (!isPlainObject3(input.config)) {
-    throw new Error('defineTool requires a "config" object');
+  if (input.inbound !== void 0 && !isPlainObject6(input.inbound)) {
+    throw new Error('defineSurface "inbound" must be an object when provided');
   }
-  const unknownKeys = Object.keys(input).filter((key) => !DEFINE_TOOL_TOP_LEVEL_KEYS.has(key));
+  if (input.outbound !== void 0 && !isPlainObject6(input.outbound)) {
+    throw new Error('defineSurface "outbound" must be an object when provided');
+  }
+  if (input.status !== void 0 && !["draft", "active", "paused"].includes(input.status)) {
+    throw new Error('defineSurface "status" must be one of: draft, active, paused');
+  }
+  if (input.environment !== void 0 && !["production", "development"].includes(input.environment)) {
+    throw new Error('defineSurface "environment" must be one of: production, development');
+  }
+  const unknownKeys = Object.keys(input).filter((key) => !DEFINE_SURFACE_TOP_LEVEL_KEYS.has(key));
   if (unknownKeys.length > 0) {
     throw new Error(
-      `defineTool: unknown field(s): ${unknownKeys.join(", ")}. Allowed fields are name, description, toolType, parametersSchema, config.`
+      `defineSurface: unknown field(s): ${unknownKeys.join(", ")}. Allowed fields are name, type, behavior, inbound, outbound, status, environment.`
     );
   }
   return {
     name: input.name,
-    description: input.description,
-    toolType: input.toolType,
-    parametersSchema: input.parametersSchema,
-    config: input.config
+    type: input.type,
+    ...input.behavior !== void 0 ? { behavior: input.behavior } : {},
+    ...input.inbound !== void 0 ? { inbound: input.inbound } : {},
+    ...input.outbound !== void 0 ? { outbound: input.outbound } : {},
+    ...input.status !== void 0 ? { status: input.status } : {},
+    ...input.environment !== void 0 ? { environment: input.environment } : {}
   };
 }
-var ToolEnsureConflictError = class extends Error {
+var SurfaceEnsureConflictError = class extends Error {
   constructor(body) {
-    super(body.error ?? `Tool ensure conflict: ${body.code}`);
-    this.name = "ToolEnsureConflictError";
+    super(body.error ?? `Surface ensure conflict: ${body.code}`);
+    this.name = "SurfaceEnsureConflictError";
     this.code = body.code;
     this.lastModifiedSource = body.lastModifiedSource;
     this.modifiedAt = body.modifiedAt;
     this.currentHash = body.currentHash;
   }
 };
-var ToolDriftError = class extends Error {
+var SurfaceDriftError = class extends Error {
   constructor(plan) {
     super(
-      `Tool "${plan.toolId ?? "definition"}" drifted: plan is '${plan.changes}' (changed: ${plan.changedKeys.join(", ") || "n/a"}). Run client.tools.pull(name) to absorb the remote edit into your repo, or re-run ensure to converge.`
+      `Surface "${plan.surfaceId ?? "definition"}" drifted: plan is '${plan.changes}' (changed: ${plan.changedKeys.join(", ") || "n/a"}). Run client.surfaces.pull(productId, name) to absorb the remote edit into your repo, or re-run ensure to converge.`
     );
-    this.name = "ToolDriftError";
+    this.name = "SurfaceDriftError";
     this.plan = plan;
   }
 };
-function parseRequestError3(err) {
+function parseRequestError6(err) {
   if (!(err instanceof Error)) return { status: null, body: null };
   const match = err.message.match(/^API request failed: (\d{3}) .*? - ([\s\S]*)$/);
   if (!match) return { status: null, body: null };
@@ -3688,47 +4391,47 @@ function parseRequestError3(err) {
     return { status: Number(match[1]), body: null };
   }
 }
-function toConflictError3(err) {
-  const { status, body } = parseRequestError3(err);
-  if (status !== 409 || !isPlainObject3(body)) return null;
+function toConflictError6(err) {
+  const { status, body } = parseRequestError6(err);
+  if (status !== 409 || !isPlainObject6(body)) return null;
   const code = body.code;
   if (code !== "external_modification" && code !== "remote_changed") return null;
-  return new ToolEnsureConflictError(
+  return new SurfaceEnsureConflictError(
     body
   );
 }
-var serverHashMemo3 = /* @__PURE__ */ new WeakMap();
-function memoFor3(client) {
-  let memo = serverHashMemo3.get(client);
+var serverHashMemo6 = /* @__PURE__ */ new WeakMap();
+function memoFor6(client) {
+  let memo = serverHashMemo6.get(client);
   if (!memo) {
     memo = /* @__PURE__ */ new Map();
-    serverHashMemo3.set(client, memo);
+    serverHashMemo6.set(client, memo);
   }
   return memo;
 }
-function memoize2(memo, memoKey, result) {
+function memoize5(memo, memoKey, result) {
   if (result.result !== "plan") memo.set(memoKey, result.contentHash);
 }
-async function request2(client, body) {
+async function request5(client, productId, body) {
   try {
     return await client.post(
-      "/tools/ensure",
+      `/products/${encodeURIComponent(productId)}/surfaces/ensure`,
       body
     );
   } catch (err) {
-    const conflict = toConflictError3(err);
+    const conflict = toConflictError6(err);
     if (conflict) throw conflict;
     throw err;
   }
 }
-async function ensureTool(client, definition, options = {}) {
+async function ensureSurface(client, productId, definition, options = {}) {
   const { dryRun, onConflict, expectedRemoteHash, expectNoChanges } = options;
   const passthrough = {
     ...onConflict ? { onConflict } : {},
     ...expectedRemoteHash ? { expectedRemoteHash } : {}
   };
   if (dryRun || expectNoChanges) {
-    const plan = await request2(client, {
+    const plan = await request5(client, productId, {
       name: definition.name,
       definition,
       dryRun: true,
@@ -3738,24 +4441,24 @@ async function ensureTool(client, definition, options = {}) {
       throw new Error(`Expected a plan result from dryRun, got '${plan.result}'`);
     }
     if (expectNoChanges && plan.changes !== "none") {
-      throw new ToolDriftError(plan);
+      throw new SurfaceDriftError(plan);
     }
     return plan;
   }
-  const memo = memoFor3(client);
-  const localHash = await computeToolContentHash(definition);
-  const memoKey = `${definition.name} ${localHash}`;
+  const memo = memoFor6(client);
+  const localHash = await computeSurfaceContentHash(definition);
+  const memoKey = `${productId} ${definition.name} ${localHash}`;
   const contentHash = memo.get(memoKey) ?? localHash;
-  const probe = await request2(client, {
+  const probe = await request5(client, productId, {
     name: definition.name,
     contentHash,
     ...passthrough
   });
   if (probe.result !== "definitionRequired") {
-    memoize2(memo, memoKey, probe);
+    memoize5(memo, memoKey, probe);
     return probe;
   }
-  const converged = await request2(client, {
+  const converged = await request5(client, productId, {
     name: definition.name,
     definition,
     ...passthrough
@@ -3763,49 +4466,51 @@ async function ensureTool(client, definition, options = {}) {
   if (converged.result === "definitionRequired") {
     throw new Error("Server reported definitionRequired for a full-definition request");
   }
-  memoize2(memo, memoKey, converged);
+  memoize5(memo, memoKey, converged);
   return converged;
 }
-async function pullTool(client, name) {
-  return client.get("/tools/pull", { name });
+async function pullSurface(client, productId, name) {
+  return client.get(
+    `/products/${encodeURIComponent(productId)}/surfaces/pull`,
+    { name }
+  );
 }
 
-// src/tools-namespace.ts
-var ToolsNamespace = class {
+// src/surfaces-namespace.ts
+var SurfacesNamespace = class {
   constructor(getClient) {
     this.getClient = getClient;
   }
   /**
-   * Idempotently converge a `defineTool` definition onto the platform.
+   * Idempotently converge a `defineSurface` definition onto a product.
    * Hash-first: the steady state is one tiny probe request. Creates or updates
-   * the saved tool; never deletes. Identity is name + account scope.
+   * the surface; never deletes. Identity is name + product.
    *
    * @example
    * ```typescript
-   * const weather = defineTool({
-   *   name: 'Weather Lookup',
-   *   description: 'Fetch the current weather for a city',
-   *   toolType: 'external',
-   *   parametersSchema: { type: 'object', properties: { city: { type: 'string' } } },
-   *   config: { url: 'https://api.example.com/weather', method: 'GET' },
+   * const chat = defineSurface({
+   *   name: 'Support Chat',
+   *   type: 'chat',
+   *   behavior: { type: 'chat', greeting: 'Hi there!' },
+   *   status: 'active',
    * })
    *
    * // Converge (CI/deploy).
-   * const result = await Runtype.tools.ensure(weather)
+   * const result = await Runtype.surfaces.ensure('product_abc', chat)
    *
    * // PR drift gate.
-   * await Runtype.tools.ensure(weather, { expectNoChanges: true })
+   * await Runtype.surfaces.ensure('product_abc', chat, { expectNoChanges: true })
    * ```
    */
-  async ensure(definition, options = {}) {
-    return ensureTool(this.getClient(), definition, options);
+  async ensure(productId, definition, options = {}) {
+    return ensureSurface(this.getClient(), productId, definition, options);
   }
   /**
-   * Pull the canonical definition + provenance for a tool by name — the
-   * absorb-drift direction of the ensure protocol.
+   * Pull the canonical definition + provenance for a surface by name within a
+   * product — the absorb-drift direction of the ensure protocol.
    */
-  async pull(name) {
-    return pullTool(this.getClient(), name);
+  async pull(productId, name) {
+    return pullSurface(this.getClient(), productId, name);
   }
 };
 
@@ -4225,6 +4930,66 @@ var Runtype = class {
   static get tools() {
     return new ToolsNamespace(() => this.getClient());
   }
+  /**
+   * Products namespace - Product config-as-code (define / ensure / pull)
+   *
+   * Converges the top-level product record (description, icon, spec). Nested
+   * capabilities/surfaces/tools and the canvas UI layout state are not
+   * converged by ensure.
+   *
+   * @example
+   * ```typescript
+   * import { defineProduct, Runtype } from '@runtypelabs/sdk'
+   *
+   * const product = defineProduct({
+   *   name: 'Support Copilot',
+   *   description: 'An AI support assistant',
+   *   icon: '🤖',
+   *   spec: { productGoal: 'Deflect tier-1 tickets', productStage: 'beta' },
+   * })
+   *
+   * // Converge at deploy time (idempotent; one tiny probe in steady state)
+   * await Runtype.products.ensure(product)
+   *
+   * // CI drift gate
+   * await Runtype.products.ensure(product, { expectNoChanges: true })
+   *
+   * // Absorb a dashboard edit back into the repo
+   * const { definition } = await Runtype.products.pull('Support Copilot')
+   * ```
+   */
+  static get products() {
+    return new ProductsNamespace(() => this.getClient());
+  }
+  /**
+   * Config-as-code operations for product surfaces. `surfaces.ensure` is the
+   * deploy-time, non-executing converge (create-or-update a surface by name
+   * within a product); `surfaces.pull` is the absorb-drift direction.
+   *
+   * @example
+   * ```typescript
+   * import { Runtype, defineSurface } from '@runtypelabs/sdk'
+   *
+   * const chat = defineSurface({
+   *   name: 'Support Chat',
+   *   type: 'chat',
+   *   behavior: { type: 'chat', greeting: 'Hi there!' },
+   *   status: 'active',
+   * })
+   *
+   * // Converge at deploy time (idempotent; one tiny probe in steady state)
+   * await Runtype.surfaces.ensure('product_abc', chat)
+   *
+   * // CI drift gate
+   * await Runtype.surfaces.ensure('product_abc', chat, { expectNoChanges: true })
+   *
+   * // Absorb a dashboard edit back into the repo
+   * const { definition } = await Runtype.surfaces.pull('product_abc', 'Support Chat')
+   * ```
+   */
+  static get surfaces() {
+    return new SurfacesNamespace(() => this.getClient());
+  }
 };
 
 // src/generated-tool-gate.ts
@@ -4447,8 +5212,8 @@ function buildGeneratedRuntimeToolGateOutput(proposal, options = {}) {
     ...decision.tool ? { tool: decision.tool } : {}
   };
 }
-function attachRuntimeToolsToDispatchRequest(request3, runtimeTools, options = {}) {
-  const stepList = request3.flow.steps;
+function attachRuntimeToolsToDispatchRequest(request6, runtimeTools, options = {}) {
+  const stepList = request6.flow.steps;
   if (!stepList || !Array.isArray(stepList) || stepList.length === 0) {
     throw new Error("Cannot attach runtime tools: dispatch request must include flow.steps");
   }
@@ -4491,9 +5256,9 @@ function attachRuntimeToolsToDispatchRequest(request3, runtimeTools, options = {
     }
   };
   return {
-    ...request3,
+    ...request6,
     flow: {
-      ...request3.flow,
+      ...request6.flow,
       // `clonedSteps` is a structural clone of `request.flow.steps` (already
       // `FlowStepDefinition[]`); only the prompt step's `config.tools` was
       // merged, so every step's `type` discriminant is preserved. The clone is
@@ -4503,12 +5268,12 @@ function attachRuntimeToolsToDispatchRequest(request3, runtimeTools, options = {
     }
   };
 }
-function applyGeneratedRuntimeToolProposalToDispatchRequest(request3, proposal, options = {}) {
+function applyGeneratedRuntimeToolProposalToDispatchRequest(request6, proposal, options = {}) {
   const decision = evaluateGeneratedRuntimeToolProposal(proposal, options.gate);
   if (!decision.approved || !decision.tool) {
-    return { decision, request: request3 };
+    return { decision, request: request6 };
   }
-  const nextRequest = attachRuntimeToolsToDispatchRequest(request3, [decision.tool], options.attach);
+  const nextRequest = attachRuntimeToolsToDispatchRequest(request6, [decision.tool], options.attach);
   return {
     decision,
     request: nextRequest
@@ -6758,15 +7523,15 @@ var DispatchEndpoint = class {
    * Attach approved runtime tools to a prompt step in a redispatch request.
    * Returns a new request object and does not mutate the original.
    */
-  attachApprovedRuntimeTools(request3, runtimeTools, options) {
-    return attachRuntimeToolsToDispatchRequest(request3, runtimeTools, options);
+  attachApprovedRuntimeTools(request6, runtimeTools, options) {
+    return attachRuntimeToolsToDispatchRequest(request6, runtimeTools, options);
   }
   /**
    * Validate a generated runtime tool proposal and attach it to the redispatch
    * request if approved, in one call.
    */
-  applyGeneratedRuntimeToolProposal(request3, proposal, options) {
-    return applyGeneratedRuntimeToolProposalToDispatchRequest(request3, proposal, options);
+  applyGeneratedRuntimeToolProposal(request6, proposal, options) {
+    return applyGeneratedRuntimeToolProposalToDispatchRequest(request6, proposal, options);
   }
 };
 var ChatEndpoint = class {
@@ -7318,8 +8083,8 @@ var GENERATED_RUNTIME_TOOL_PROPOSAL_SCHEMA = {
   },
   required: ["name", "description", "toolType", "parametersSchema", "config"]
 };
-function appendRuntimeToolsToAgentRequest(request3, runtimeTools) {
-  const existing = request3.tools?.runtimeTools || [];
+function appendRuntimeToolsToAgentRequest(request6, runtimeTools) {
+  const existing = request6.tools?.runtimeTools || [];
   const existingNames = new Set(existing.map((tool) => tool.name));
   const converted = runtimeTools.filter((tool) => !existingNames.has(tool.name)).map((tool) => ({
     name: tool.name,
@@ -7329,9 +8094,9 @@ function appendRuntimeToolsToAgentRequest(request3, runtimeTools) {
     ...tool.config ? { config: tool.config } : {}
   }));
   return {
-    ...request3,
+    ...request6,
     tools: {
-      ...request3.tools,
+      ...request6.tools,
       runtimeTools: [...existing, ...converted]
     }
   };
@@ -7407,21 +8172,21 @@ var _AgentsEndpoint = class _AgentsEndpoint {
    * Attach approved runtime tools to an agent execute request.
    * Returns a new request object and does not mutate the original.
    */
-  attachApprovedRuntimeTools(request3, runtimeTools) {
-    return appendRuntimeToolsToAgentRequest(request3, runtimeTools);
+  attachApprovedRuntimeTools(request6, runtimeTools) {
+    return appendRuntimeToolsToAgentRequest(request6, runtimeTools);
   }
   /**
    * Validate a generated runtime tool proposal and append it to an agent execute
    * request if approved, in one call.
    */
-  applyGeneratedRuntimeToolProposal(request3, proposal, options) {
+  applyGeneratedRuntimeToolProposal(request6, proposal, options) {
     const decision = evaluateGeneratedRuntimeToolProposal(proposal, options);
     if (!decision.approved || !decision.tool) {
-      return { decision, request: request3 };
+      return { decision, request: request6 };
     }
     return {
       decision,
-      request: appendRuntimeToolsToAgentRequest(request3, [decision.tool])
+      request: appendRuntimeToolsToAgentRequest(request6, [decision.tool])
     };
   }
   /**
@@ -10522,6 +11287,29 @@ var BillingEndpoint = class {
     return this.client.get("/billing/spend-analytics", params);
   }
 };
+var ToolApprovalGrantsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List active remembered tool-approval grants for the authenticated owner,
+   * optionally filtered to a single agent.
+   */
+  async list(agentId) {
+    const query = agentId ? `?agentId=${encodeURIComponent(agentId)}` : "";
+    const response = await this.client.get(
+      `/tool-approval-grants${query}`
+    );
+    return response.data;
+  }
+  /**
+   * Revoke (soft-delete) a remembered grant so the tool prompts for approval
+   * again on future dispatches.
+   */
+  async revoke(id) {
+    return this.client.delete(`/tool-approval-grants/${id}`);
+  }
+};
 var AppsEndpoint = class {
   constructor(client) {
     this.client = client;
@@ -10619,6 +11407,7 @@ var RuntypeClient2 = class {
     this.flowVersions = new FlowVersionsEndpoint(this);
     this.integrations = new IntegrationsEndpoint(this);
     this.billing = new BillingEndpoint(this);
+    this.toolApprovalGrants = new ToolApprovalGrantsEndpoint(this);
   }
   /**
    * Set the API key for authentication
@@ -10657,7 +11446,7 @@ var RuntypeClient2 = class {
   clearApiKey() {
     delete this.headers.Authorization;
   }
-  async runWithLocalTools(request3, localTools, arg3, arg4) {
+  async runWithLocalTools(request6, localTools, arg3, arg4) {
     const isOptionsObject = (val) => typeof val === "object" && val !== null && "scope" in val;
     const callbacks = isOptionsObject(arg3) ? void 0 : arg3;
     const options = (isOptionsObject(arg3) ? arg3 : arg4) ?? {};
@@ -10671,12 +11460,12 @@ var RuntypeClient2 = class {
       ...entry.pageOrigin ? { pageOrigin: entry.pageOrigin } : {}
     })) : [];
     const modifiedRequest = {
-      ...request3,
+      ...request6,
       ...derivedClientTools.length > 0 ? {
-        clientTools: [...request3.clientTools ?? [], ...derivedClientTools]
+        clientTools: [...request6.clientTools ?? [], ...derivedClientTools]
       } : {},
       options: {
-        ...request3.options || {},
+        ...request6.options || {},
         streamResponse: isStreaming
       }
     };
@@ -11114,20 +11903,20 @@ var BatchBuilder = class {
     if (!this.recordType) {
       throw new Error("BatchBuilder: recordType is required. Call .forRecordType(type) first.");
     }
-    const request3 = {
+    const request6 = {
       flowId: this.flowId,
       recordType: this.recordType
     };
     if (Object.keys(this.batchOptions).length > 0) {
-      request3.options = this.batchOptions;
+      request6.options = this.batchOptions;
     }
     if (this.filterConfig) {
-      request3.filter = this.filterConfig;
+      request6.filter = this.filterConfig;
     }
     if (this.limitConfig !== void 0) {
-      request3.limit = this.limitConfig;
+      request6.limit = this.limitConfig;
     }
-    return request3;
+    return request6;
   }
   /**
    * Execute the batch operation
@@ -11284,32 +12073,32 @@ var EvalBuilder = class {
         "EvalBuilder: records are required. Call .forRecordType(type) or .withRecords([...]) first."
       );
     }
-    const request3 = {};
+    const request6 = {};
     if (this.flowId) {
-      request3.flowId = this.flowId;
+      request6.flowId = this.flowId;
     } else if (this.virtualFlow) {
-      request3.flow = this.virtualFlow;
+      request6.flow = this.virtualFlow;
     }
     if (this.recordType) {
-      request3.recordType = this.recordType;
+      request6.recordType = this.recordType;
     } else if (this.inlineRecords) {
-      request3.records = this.inlineRecords;
+      request6.records = this.inlineRecords;
     }
     if (this.modelOverrides) {
-      request3.modelOverrides = this.modelOverrides;
+      request6.modelOverrides = this.modelOverrides;
     } else if (this.modelConfigs) {
-      request3.modelConfigs = this.modelConfigs;
+      request6.modelConfigs = this.modelConfigs;
     }
     if (Object.keys(this.evalOptions).length > 0) {
-      request3.options = this.evalOptions;
+      request6.options = this.evalOptions;
     }
     if (this.filterConfig) {
-      request3.filter = this.filterConfig;
+      request6.filter = this.filterConfig;
     }
     if (this.limitConfig !== void 0) {
-      request3.limit = this.limitConfig;
+      request6.limit = this.limitConfig;
     }
-    return request3;
+    return request6;
   }
   /**
    * Execute the evaluation
@@ -11812,6 +12601,9 @@ export {
   LEDGER_ARTIFACT_LINE_PREFIX,
   LogsEndpoint,
   ModelConfigsEndpoint,
+  ProductDriftError,
+  ProductEnsureConflictError,
+  ProductsNamespace,
   PromptRunner,
   PromptsEndpoint,
   PromptsNamespace,
@@ -11825,9 +12617,15 @@ export {
   STEP_TYPE_TO_METHOD,
   SchedulesEndpoint,
   SecretsEndpoint,
+  SkillDriftError,
+  SkillEnsureConflictError,
   SkillProposalsNamespace,
   SkillsNamespace,
+  SurfaceDriftError,
+  SurfaceEnsureConflictError,
   SurfacesEndpoint,
+  SurfacesNamespace,
+  ToolApprovalGrantsEndpoint,
   ToolDriftError,
   ToolEnsureConflictError,
   ToolsEndpoint,
@@ -11843,6 +12641,9 @@ export {
   compileWorkflowConfig,
   computeAgentContentHash,
   computeFlowContentHash,
+  computeProductContentHash,
+  computeSkillContentHash,
+  computeSurfaceContentHash,
   computeToolContentHash,
   createClient,
   createExternalTool,
@@ -11851,6 +12652,9 @@ export {
   defineAgent,
   defineFlow,
   definePlaybook,
+  defineProduct,
+  defineSkill,
+  defineSurface,
   defineTool,
   deployWorkflow,
   ensureDefaultWorkflowHooks,
@@ -11867,6 +12671,9 @@ export {
   listWorkflowHooks,
   normalizeAgentDefinition,
   normalizeCandidatePath,
+  normalizeProductDefinition,
+  normalizeSkillDefinition,
+  normalizeSurfaceDefinition,
   normalizeToolDefinition,
   parseFinalBuffer,
   parseLedgerArtifactRelativePath,