@runtypelabs/cli 2.16.3 → 2.16.5

package/dist/index.js

@@ -15732,6 +15732,16 @@ var productConfigurationSummarySchema = external_exports.object({
 var ORGANIZATION_INTEGRATION_PROVIDERS = ["slack", "telegram", "discord", "linear", "github"];
 var integrationProviderSchema = external_exports.enum(ORGANIZATION_INTEGRATION_PROVIDERS);
 var integrationStatusSchema = external_exports.enum(["active", "revoked", "pending"]);
+var setVariableConfigSchema = external_exports.object({
+  variableName: external_exports.string().min(1, "Variable name is required"),
+  // The object branch is modeled as a record (rather than the historical
+  // `z.object({})`) so the inferred union keeps its primitive members distinct:
+  // a bare `{}` is a supertype of `string | number | boolean` and would absorb
+  // them, degrading `value` to `{}`. A record accepts exactly the same inputs as
+  // the prior `z.object({})` (any plain object, never an array or primitive).
+  value: external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean(), external_exports.record(external_exports.string(), external_exports.unknown())]),
+  valueTemplate: external_exports.string().optional()
+});
 var SERIALIZED_HELPERS_SOURCE = `
 // Transform helper functions (from packages/shared/src/transform-helpers.ts)
 const helpers = (function createHelpers() {
@@ -33716,6 +33726,156 @@ var SLACK_MANIFEST_BOT_SCOPES = [
   ...SLACK_REQUIRED_BOT_SCOPES,
   ...SLACK_OPTIONAL_BOT_SCOPES
 ];
+var reasoningConfigSchema = external_exports.union([
+  external_exports.boolean(),
+  external_exports.object({
+    enabled: external_exports.boolean(),
+    // OpenAI GPT-5 and o-series
+    reasoningEffort: external_exports.enum(["minimal", "low", "medium", "high", "xhigh"]).optional(),
+    reasoningSummary: external_exports.enum(["auto", "detailed"]).optional(),
+    // Anthropic Claude
+    budgetTokens: external_exports.number().int().min(1e3).max(1e5).optional(),
+    // Google Gemini
+    thinkingBudget: external_exports.number().int().min(1024).max(65536).optional(),
+    includeThoughts: external_exports.boolean().optional()
+  })
+]);
+var samplingConfigSchema = {
+  topP: external_exports.number().min(0).max(1).optional(),
+  topK: external_exports.number().int().min(1).max(500).optional(),
+  frequencyPenalty: external_exports.number().min(-2).max(2).optional(),
+  presencePenalty: external_exports.number().min(-2).max(2).optional(),
+  seed: external_exports.number().int().optional()
+};
+var errorHandlingSchema = external_exports.object({
+  onError: external_exports.enum(["fail", "continue", "fallback"]),
+  fallbacks: external_exports.array(
+    external_exports.discriminatedUnion("type", [
+      external_exports.object({
+        type: external_exports.literal("retry"),
+        delay: external_exports.number().int().min(0).max(6e4).optional()
+      }),
+      external_exports.object({
+        type: external_exports.literal("model"),
+        model: external_exports.string(),
+        temperature: external_exports.number().min(0).max(2).optional(),
+        maxTokens: external_exports.number().int().min(1).optional(),
+        delay: external_exports.number().int().min(0).max(6e4).optional()
+      }),
+      external_exports.object({
+        type: external_exports.literal("message"),
+        message: external_exports.string(),
+        delay: external_exports.number().int().min(0).max(6e4).optional()
+      })
+    ])
+  ).optional(),
+  // Conditions that activate the fallback chain. Mirrors PromptErrorHandling.triggers;
+  // defaults to error-only when omitted.
+  triggers: external_exports.array(external_exports.object({ type: external_exports.enum(["error", "empty-output"]) })).optional()
+}).optional();
+var artifactConfigSchema = external_exports.object({
+  enabled: external_exports.literal(true),
+  types: external_exports.array(external_exports.enum(["markdown", "component"])).min(1)
+});
+var agentRuntimeConfigSchema = external_exports.object({
+  model: external_exports.string().optional(),
+  systemPrompt: external_exports.string().optional(),
+  temperature: external_exports.number().min(0).max(2).optional(),
+  ...samplingConfigSchema,
+  // Unified tools configuration (nested under 'tools')
+  tools: external_exports.object({
+    toolIds: external_exports.array(external_exports.string()).optional(),
+    toolConfigs: external_exports.record(external_exports.string(), external_exports.record(external_exports.string(), external_exports.unknown())).optional(),
+    runtimeTools: external_exports.array(
+      external_exports.object({
+        name: external_exports.string(),
+        description: external_exports.string(),
+        toolType: external_exports.enum([
+          "flow",
+          "custom",
+          "external",
+          "local",
+          "advisor",
+          "subagent",
+          "search"
+        ]),
+        parametersSchema: external_exports.record(external_exports.string(), external_exports.unknown()),
+        config: external_exports.record(external_exports.string(), external_exports.unknown())
+      })
+    ).optional(),
+    mcpServers: external_exports.array(
+      external_exports.object({
+        id: external_exports.string(),
+        name: external_exports.string().optional(),
+        url: external_exports.string(),
+        auth: external_exports.object({
+          type: external_exports.enum(["api_key", "bearer", "basic", "custom_header", "none"]),
+          headerName: external_exports.string().optional(),
+          token: external_exports.string().optional(),
+          username: external_exports.string().optional(),
+          password: external_exports.string().optional()
+        }).optional(),
+        allowedTools: external_exports.array(external_exports.string()).optional(),
+        timeout: external_exports.number().optional(),
+        transport: external_exports.enum(["streamable_http", "rest"]).optional(),
+        enabled: external_exports.boolean().optional()
+      })
+    ).optional(),
+    maxToolCalls: external_exports.number().int().min(1).max(100).optional(),
+    toolCallStrategy: external_exports.enum(["auto", "required", "none"]).optional(),
+    parallelCalls: external_exports.boolean().optional(),
+    approval: external_exports.object({
+      require: external_exports.union([external_exports.array(external_exports.string()), external_exports.boolean()]),
+      timeout: external_exports.number().optional()
+    }).optional(),
+    perToolLimits: external_exports.record(
+      external_exports.string(),
+      external_exports.object({
+        maxCalls: external_exports.number().optional(),
+        required: external_exports.boolean().optional()
+      })
+    ).optional(),
+    subagentConfig: external_exports.object({
+      toolPool: external_exports.array(external_exports.string()),
+      defaultMaxTurns: external_exports.number().int().min(1).max(100).optional(),
+      maxTurnsLimit: external_exports.number().int().min(1).max(100).optional(),
+      maxSpawnsPerRun: external_exports.number().int().min(1).max(50).optional(),
+      defaultModel: external_exports.string().optional(),
+      allowNesting: external_exports.boolean().optional(),
+      defaultTimeoutMs: external_exports.number().int().min(1e3).max(6e5).optional()
+    }).optional(),
+    codeModeConfig: external_exports.object({
+      toolPool: external_exports.array(external_exports.string()),
+      description: external_exports.string().optional(),
+      timeoutMs: external_exports.number().int().min(1e3).max(6e5).optional()
+    }).optional()
+  }).optional(),
+  artifacts: artifactConfigSchema.optional(),
+  reasoning: reasoningConfigSchema.optional(),
+  advisor: external_exports.object({
+    model: external_exports.string(),
+    systemPrompt: external_exports.string().optional()
+  }).optional().nullable(),
+  loopConfig: external_exports.object({
+    maxTurns: external_exports.number().int().min(1).max(100).optional(),
+    maxCost: external_exports.number().min(0).optional(),
+    enableReflection: external_exports.boolean().optional(),
+    reflectionInterval: external_exports.number().int().min(1).max(50).optional()
+  }).optional(),
+  voice: external_exports.object({
+    enabled: external_exports.boolean().optional(),
+    provider: external_exports.string().optional(),
+    interruptionMode: external_exports.enum(["none", "cancel", "barge-in"]).optional(),
+    elevenLabs: external_exports.object({
+      voiceId: external_exports.string().optional(),
+      modelId: external_exports.string().optional(),
+      stability: external_exports.number().min(0).max(1).optional(),
+      similarity: external_exports.number().min(0).max(1).optional()
+    }).optional()
+  }).optional(),
+  errorHandling: errorHandlingSchema,
+  loggingPolicy: external_exports.enum(["default", "on", "off"]).optional()
+});
 var SECRET_REF_PATTERN = /\{\{secret:([A-Z][A-Z0-9_]*[A-Z0-9])\}\}/g;
 function extractSecretReferences(template) {
   const keys = /* @__PURE__ */ new Set();
@@ -33750,6 +33910,7 @@ function extractSecretReferencesFromAnyValue(value, maxDepth = 10) {
 }
 var FULL_PRODUCT_OBJECT_VERSION_1_0 = "1.0";
 var FULL_PRODUCT_OBJECT_VERSION_1_1 = "1.1";
+var FULL_PRODUCT_OBJECT_VERSION_2_0 = "2.0";
 var createPolicySchema = external_exports.enum(["create", "skip", "manual"]).optional();
 var flowStepSchema = external_exports.object({
   type: external_exports.string().refine(
@@ -33928,6 +34089,23 @@ var agentDefinitionSchema = external_exports.object({
   claudeManagedConfig: agentClaudeManagedConfigSchema.optional(),
   createPolicy: createPolicySchema
 });
+var agentDefinitionSchemaV2 = external_exports.object({
+  name: external_exports.string().min(1),
+  description: external_exports.string().min(1),
+  icon: external_exports.string().max(50).optional(),
+  agentType: external_exports.enum(["runtype", "external", "claude_managed"]).optional(),
+  // Canonical runtime config — identical to `createAgentSchema.config`.
+  config: agentRuntimeConfigSchema.optional(),
+  // FPO-specific wiring, top-level like the flat shape.
+  capabilityToolRefs: external_exports.array(capabilityToolRefSchema).optional(),
+  // External / managed agent configs (top-level, mirroring `createAgent`).
+  externalConfig: agentExternalConfigSchema.optional(),
+  claudeManagedConfig: agentClaudeManagedConfigSchema.optional(),
+  createPolicy: createPolicySchema
+}).strict();
+function isNestedFpoAgent(agent) {
+  return !!agent && typeof agent === "object" && "config" in agent && !("model" in agent);
+}
 var capabilitySchema = external_exports.object({
   id: external_exports.string().min(1),
   name: external_exports.string().min(1),
@@ -33935,7 +34113,12 @@ var capabilitySchema = external_exports.object({
   inputSchema: external_exports.record(external_exports.string(), external_exports.any()).optional(),
   outputSchema: external_exports.record(external_exports.string(), external_exports.any()).optional(),
   flow: flowDefinitionSchema.optional(),
-  agent: agentDefinitionSchema.optional(),
+  // Accept BOTH inline-agent shapes. The flat ≤1.1 shape requires a top-level
+  // `model`; the v2 shape is `.strict()` with no top-level `model`. These are
+  // mutually exclusive, so the union routes unambiguously. Version-consistency
+  // (flat ↔ ≤1.1, nested ↔ 2.0) is enforced in `fullProductObjectSchema`'s
+  // superRefine, which has access to the document `version`.
+  agent: external_exports.union([agentDefinitionSchema, agentDefinitionSchemaV2]).optional(),
   existingFlowId: external_exports.string().optional(),
   existingAgentId: external_exports.string().optional()
 }).refine(
@@ -34075,7 +34258,11 @@ var metaSchema = external_exports.object({
   planHash: external_exports.string().min(1)
 });
 var fullProductObjectSchema = external_exports.object({
-  version: external_exports.enum([FULL_PRODUCT_OBJECT_VERSION_1_0, FULL_PRODUCT_OBJECT_VERSION_1_1]),
+  version: external_exports.enum([
+    FULL_PRODUCT_OBJECT_VERSION_1_0,
+    FULL_PRODUCT_OBJECT_VERSION_1_1,
+    FULL_PRODUCT_OBJECT_VERSION_2_0
+  ]),
   product: external_exports.object({
     name: external_exports.string().min(1),
     description: external_exports.string().min(1),
@@ -34090,78 +34277,24 @@ var fullProductObjectSchema = external_exports.object({
   secrets: external_exports.array(productSecretSchema).max(50).optional(),
   _meta: metaSchema
 }).superRefine((fpo, ctx) => {
-  const capIds = /* @__PURE__ */ new Set();
+  const isV2 = fpo.version === FULL_PRODUCT_OBJECT_VERSION_2_0;
   for (const [i, cap] of fpo.capabilities.entries()) {
-    const id = cap.id;
-    if (capIds.has(id)) {
+    const agent = cap.agent;
+    if (!agent || typeof agent !== "object") continue;
+    const looksNested = "config" in agent && !("model" in agent);
+    if (isV2 && !looksNested) {
       ctx.addIssue({
         code: "custom",
-        message: `Duplicate capability id: ${id}`,
-        path: ["capabilities", i, "id"]
+        message: "Version 2.0 requires the nested inline-agent shape: put model/systemPrompt/tools under `agent.config`.",
+        path: ["capabilities", i, "agent"]
       });
-    }
-    capIds.add(id);
-  }
-  const toolIds = /* @__PURE__ */ new Set();
-  for (const [i, tool] of fpo.tools.entries()) {
-    if (toolIds.has(tool.id)) {
-      ctx.addIssue({
-        code: "custom",
-        message: `Duplicate tool id: ${tool.id}`,
-        path: ["tools", i, "id"]
-      });
-    }
-    toolIds.add(tool.id);
-  }
-  const surfaceIds = /* @__PURE__ */ new Set();
-  for (const [i, surface] of fpo.surfaces.entries()) {
-    if (surfaceIds.has(surface.id)) {
+    } else if (!isV2 && looksNested) {
       ctx.addIssue({
         code: "custom",
-        message: `Duplicate surface id: ${surface.id}`,
-        path: ["surfaces", i, "id"]
+        message: 'The nested `agent.config` shape requires version "2.0". Use the flat agent shape for version 1.0/1.1, or set version to "2.0".',
+        path: ["capabilities", i, "agent"]
       });
     }
-    surfaceIds.add(surface.id);
-  }
-  if (fpo.records) {
-    const recordIds = /* @__PURE__ */ new Set();
-    for (const [i, record2] of fpo.records.entries()) {
-      if (recordIds.has(record2.id)) {
-        ctx.addIssue({
-          code: "custom",
-          message: `Duplicate record id: ${record2.id}`,
-          path: ["records", i, "id"]
-        });
-      }
-      recordIds.add(record2.id);
-    }
-  }
-  if (fpo.schedules) {
-    const scheduleIds = /* @__PURE__ */ new Set();
-    for (const [i, schedule] of fpo.schedules.entries()) {
-      if (scheduleIds.has(schedule.id)) {
-        ctx.addIssue({
-          code: "custom",
-          message: `Duplicate schedule id: ${schedule.id}`,
-          path: ["schedules", i, "id"]
-        });
-      }
-      scheduleIds.add(schedule.id);
-    }
-  }
-  if (fpo.secrets) {
-    const secretIds = /* @__PURE__ */ new Set();
-    for (const [i, secret] of fpo.secrets.entries()) {
-      if (secretIds.has(secret.id)) {
-        ctx.addIssue({
-          code: "custom",
-          message: `Duplicate secret id: ${secret.id}`,
-          path: ["secrets", i, "id"]
-        });
-      }
-      secretIds.add(secret.id);
-    }
   }
 });
 function createIssue(severity, code, message, path16, suggestedFix) {
@@ -34254,6 +34387,29 @@ function validateAgentDefinition(agent, capIndex) {
       createIssue("error", "AGENT_NAME_EMPTY", "Agent name is required", `${base}.name`)
     );
   }
+  if (isNestedFpoAgent(agent)) {
+    validateNestedAgent(agent, base, result);
+  } else {
+    validateFlatAgent(agent, base, result);
+  }
+  if (agent.capabilityToolRefs) {
+    for (const [i, ref] of agent.capabilityToolRefs.entries()) {
+      if (!ref.toolName || ref.toolName.trim() === "") {
+        result.errors.push(
+          createIssue("error", "CAPABILITY_TOOL_REF_NAME_EMPTY", "capabilityToolRefs toolName is required", `${base}.capabilityToolRefs[${i}].toolName`)
+        );
+      }
+      if (!ref.capabilityId || ref.capabilityId.trim() === "") {
+        result.errors.push(
+          createIssue("error", "CAPABILITY_TOOL_REF_ID_EMPTY", "capabilityToolRefs capabilityId is required", `${base}.capabilityToolRefs[${i}].capabilityId`)
+        );
+      }
+    }
+  }
+  result.valid = result.errors.length === 0;
+  return result;
+}
+function validateFlatAgent(agent, base, result) {
   if (!agent.model || agent.model.trim() === "") {
     result.errors.push(
       createIssue("error", "AGENT_NO_MODEL", "Agent model is required", `${base}.model`)
@@ -34289,22 +34445,35 @@ function validateAgentDefinition(agent, capIndex) {
       }
     }
   }
-  if (agent.capabilityToolRefs) {
-    for (const [i, ref] of agent.capabilityToolRefs.entries()) {
-      if (!ref.toolName || ref.toolName.trim() === "") {
+}
+function validateNestedAgent(agent, base, result) {
+  const config3 = agent.config;
+  if (!config3?.model || config3.model.trim() === "") {
+    result.errors.push(
+      createIssue("error", "AGENT_NO_MODEL", "Agent model is required", `${base}.config.model`)
+    );
+  }
+  if (config3?.advisor) {
+    if (!config3.advisor.model || config3.advisor.model.trim() === "") {
+      result.errors.push(
+        createIssue("error", "AGENT_ADVISOR_NO_MODEL", "Advisor model is required when advisor is configured", `${base}.config.advisor.model`)
+      );
+    }
+  }
+  if (config3?.tools?.runtimeTools) {
+    for (const [i, tool] of config3.tools.runtimeTools.entries()) {
+      if (!tool.name || tool.name.trim() === "") {
         result.errors.push(
-          createIssue("error", "CAPABILITY_TOOL_REF_NAME_EMPTY", "capabilityToolRefs toolName is required", `${base}.capabilityToolRefs[${i}].toolName`)
+          createIssue("error", "RUNTIME_TOOL_NAME_EMPTY", "Runtime tool name is required", `${base}.config.tools.runtimeTools[${i}].name`)
         );
       }
-      if (!ref.capabilityId || ref.capabilityId.trim() === "") {
-        result.errors.push(
-          createIssue("error", "CAPABILITY_TOOL_REF_ID_EMPTY", "capabilityToolRefs capabilityId is required", `${base}.capabilityToolRefs[${i}].capabilityId`)
+      if (tool.toolType === "flow" && (!tool.config?.steps || !Array.isArray(tool.config.steps) || tool.config.steps.length === 0)) {
+        result.warnings.push(
+          createIssue("warning", "FLOW_RUNTIME_TOOL_NO_STEPS", "Flow runtime tool should have steps in config", `${base}.config.tools.runtimeTools[${i}].config.steps`)
         );
       }
     }
   }
-  result.valid = result.errors.length === 0;
-  return result;
 }
 var KEBAB_CASE_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 function validateCapability(cap, index, context) {
@@ -34521,7 +34690,16 @@ function validateConnectivity(fpo) {
     }
   }
   for (const [ci, cap] of fpo.capabilities.entries()) {
-    const toolIds = cap.agent?.toolsConfig?.toolIds;
+    const agent = cap.agent;
+    let toolIds;
+    let toolIdsPath;
+    if (isNestedFpoAgent(agent)) {
+      toolIds = agent.config?.tools?.toolIds;
+      toolIdsPath = "config.tools.toolIds";
+    } else {
+      toolIds = agent?.toolsConfig?.toolIds;
+      toolIdsPath = "toolsConfig.toolIds";
+    }
     if (!toolIds) continue;
     for (const [ti, toolId] of toolIds.entries()) {
       if (!toolId.startsWith("capability:")) continue;
@@ -34533,7 +34711,7 @@ function validateConnectivity(fpo) {
             "error",
             "CAPABILITY_TOOLID_REF_NOT_FOUND",
             `toolIds references non-existent capability "${refCapId}"`,
-            `capabilities[${ci}].agent.toolsConfig.toolIds[${ti}]`,
+            `capabilities[${ci}].agent.${toolIdsPath}[${ti}]`,
             "Ensure the capability:<id> matches an existing capability"
           )
         );
@@ -34543,7 +34721,7 @@ function validateConnectivity(fpo) {
             "error",
             "CAPABILITY_TOOLID_REF_NOT_FLOW",
             `toolIds references capability "${refCapId}" which is not a flow capability`,
-            `capabilities[${ci}].agent.toolsConfig.toolIds[${ti}]`,
+            `capabilities[${ci}].agent.${toolIdsPath}[${ti}]`,
             "capability: refs in toolIds can only reference capabilities backed by a flow"
           )
         );
@@ -34554,7 +34732,7 @@ function validateConnectivity(fpo) {
             "error",
             "CAPABILITY_TOOLID_REF_SELF",
             `toolIds cannot reference the capability's own id "${cap.id}"`,
-            `capabilities[${ci}].agent.toolsConfig.toolIds[${ti}]`
+            `capabilities[${ci}].agent.${toolIdsPath}[${ti}]`
           )
         );
       }
@@ -34589,59 +34767,80 @@ function validateConnectivity(fpo) {
   result.valid = result.errors.length === 0;
   return result;
 }
+function safeValidate(fn) {
+  try {
+    return fn();
+  } catch {
+    return emptyResult();
+  }
+}
+function readId(entry) {
+  return entry && typeof entry === "object" ? entry.id : void 0;
+}
 function validateFPO(fpo) {
   const result = emptyResult();
   const capIds = /* @__PURE__ */ new Set();
   for (const [i, cap] of fpo.capabilities.entries()) {
-    if (capIds.has(cap.id)) {
+    const id = readId(cap);
+    if (id === void 0) continue;
+    if (capIds.has(id)) {
       result.errors.push(
-        createIssue("error", "DUPLICATE_CAPABILITY_ID", `Duplicate capability id: "${cap.id}"`, `capabilities[${i}].id`)
+        createIssue("error", "DUPLICATE_CAPABILITY_ID", `Duplicate capability id: "${id}"`, `capabilities[${i}].id`)
       );
     }
-    capIds.add(cap.id);
+    capIds.add(id);
   }
   const toolIdSet = /* @__PURE__ */ new Set();
   for (const [i, tool] of fpo.tools.entries()) {
-    if (toolIdSet.has(tool.id)) {
+    const id = readId(tool);
+    if (id === void 0) continue;
+    if (toolIdSet.has(id)) {
       result.errors.push(
-        createIssue("error", "DUPLICATE_TOOL_ID", `Duplicate tool id: "${tool.id}"`, `tools[${i}].id`)
+        createIssue("error", "DUPLICATE_TOOL_ID", `Duplicate tool id: "${id}"`, `tools[${i}].id`)
       );
     }
-    toolIdSet.add(tool.id);
+    toolIdSet.add(id);
   }
   const surfaceIds = /* @__PURE__ */ new Set();
   for (const [i, surface] of fpo.surfaces.entries()) {
-    if (surfaceIds.has(surface.id)) {
+    const id = readId(surface);
+    if (id === void 0) continue;
+    if (surfaceIds.has(id)) {
       result.errors.push(
-        createIssue("error", "DUPLICATE_SURFACE_ID", `Duplicate surface id: "${surface.id}"`, `surfaces[${i}].id`)
+        createIssue("error", "DUPLICATE_SURFACE_ID", `Duplicate surface id: "${id}"`, `surfaces[${i}].id`)
       );
     }
-    surfaceIds.add(surface.id);
+    surfaceIds.add(id);
   }
   if (fpo.records) {
     const recordIds = /* @__PURE__ */ new Set();
     for (const [i, record2] of fpo.records.entries()) {
-      if (recordIds.has(record2.id)) {
+      const id = readId(record2);
+      if (id === void 0) continue;
+      if (recordIds.has(id)) {
         result.errors.push(
-          createIssue("error", "DUPLICATE_RECORD_ID", `Duplicate record id: "${record2.id}"`, `records[${i}].id`)
+          createIssue("error", "DUPLICATE_RECORD_ID", `Duplicate record id: "${id}"`, `records[${i}].id`)
         );
       }
-      recordIds.add(record2.id);
+      recordIds.add(id);
     }
   }
-  const capIdSet = new Set(fpo.capabilities.map((c) => c.id));
   if (fpo.schedules) {
     const scheduleIds = /* @__PURE__ */ new Set();
     for (const [i, schedule] of fpo.schedules.entries()) {
-      if (scheduleIds.has(schedule.id)) {
-        result.errors.push(
-          createIssue("error", "DUPLICATE_SCHEDULE_ID", `Duplicate schedule id: "${schedule.id}"`, `schedules[${i}].id`)
-        );
+      const id = readId(schedule);
+      if (id !== void 0) {
+        if (scheduleIds.has(id)) {
+          result.errors.push(
+            createIssue("error", "DUPLICATE_SCHEDULE_ID", `Duplicate schedule id: "${id}"`, `schedules[${i}].id`)
+          );
+        }
+        scheduleIds.add(id);
       }
-      scheduleIds.add(schedule.id);
-      if (!capIdSet.has(schedule.capabilityId)) {
+      const capabilityId = schedule && typeof schedule === "object" ? schedule.capabilityId : void 0;
+      if (capabilityId !== void 0 && !capIds.has(capabilityId)) {
         result.errors.push(
-          createIssue("error", "SCHEDULE_CAPABILITY_NOT_FOUND", `Schedule "${schedule.id}" references capability "${schedule.capabilityId}" which does not exist`, `schedules[${i}].capabilityId`)
+          createIssue("error", "SCHEDULE_CAPABILITY_NOT_FOUND", `Schedule "${readId(schedule) ?? ""}" references capability "${capabilityId}" which does not exist`, `schedules[${i}].capabilityId`)
         );
       }
     }
@@ -34649,23 +34848,81 @@ function validateFPO(fpo) {
   if (fpo.secrets) {
     const secretIds = /* @__PURE__ */ new Set();
     for (const [i, secret] of fpo.secrets.entries()) {
-      if (secretIds.has(secret.id)) {
+      const id = readId(secret);
+      if (id === void 0) continue;
+      if (secretIds.has(id)) {
         result.errors.push(
-          createIssue("error", "DUPLICATE_SECRET_ID", `Duplicate secret id: "${secret.id}"`, `secrets[${i}].id`)
+          createIssue("error", "DUPLICATE_SECRET_ID", `Duplicate secret id: "${id}"`, `secrets[${i}].id`)
         );
       }
-      secretIds.add(secret.id);
+      secretIds.add(id);
     }
   }
-  const toolIds = new Set(fpo.tools.map((t) => t.id));
+  const toolIds = new Set(
+    [...toolIdSet].filter((id) => typeof id === "string")
+  );
   const capResults = fpo.capabilities.map(
-    (cap, i) => validateCapability(cap, i, { toolIds })
+    (cap, i) => safeValidate(() => validateCapability(cap, i, { toolIds }))
+  );
+  const toolResults = fpo.tools.map(
+    (tool, i) => safeValidate(() => validateToolDefinition(tool, i))
+  );
+  const surfaceResults = fpo.surfaces.map(
+    (surface, i) => safeValidate(() => validateSurfaceDefinition(surface, i))
   );
-  const toolResults = fpo.tools.map((tool, i) => validateToolDefinition(tool, i));
-  const surfaceResults = fpo.surfaces.map((surface, i) => validateSurfaceDefinition(surface, i));
-  const connectivityResult = validateConnectivity(fpo);
+  const connectivityResult = safeValidate(() => validateConnectivity(fpo));
   return mergeResults(result, ...capResults, ...toolResults, ...surfaceResults, connectivityResult);
 }
+function zodIssueCodeToValidationCode(code) {
+  return code ? `SCHEMA_${code.toUpperCase()}` : "SCHEMA_ERROR";
+}
+function zodIssuesToValidationIssues(issues) {
+  return issues.map(
+    (issue2) => createIssue(
+      "error",
+      zodIssueCodeToValidationCode(issue2.code),
+      issue2.message,
+      issue2.path.map(String).join(".")
+    )
+  );
+}
+function zodIssuesToValidationResult(issues) {
+  const result = emptyResult();
+  result.errors.push(...zodIssuesToValidationIssues(issues));
+  result.valid = false;
+  return result;
+}
+function mergeZodSchemaAndSemantic(parsed, fallbackSemanticInput, validate) {
+  if (parsed.success) {
+    return validate(parsed.data);
+  }
+  const schemaResult = zodIssuesToValidationResult(parsed.error.issues);
+  if (fallbackSemanticInput === null || fallbackSemanticInput === void 0) {
+    return schemaResult;
+  }
+  let semanticResult;
+  try {
+    semanticResult = validate(fallbackSemanticInput);
+  } catch {
+    semanticResult = emptyResult();
+  }
+  const merged = mergeResults(schemaResult, semanticResult);
+  merged.valid = false;
+  return merged;
+}
+function coerceFullProductObjectForSemanticValidation(body) {
+  if (typeof body !== "object" || body === null) return null;
+  const obj = body;
+  return {
+    ...obj,
+    capabilities: Array.isArray(obj.capabilities) ? obj.capabilities : [],
+    tools: Array.isArray(obj.tools) ? obj.tools : [],
+    surfaces: Array.isArray(obj.surfaces) ? obj.surfaces : [],
+    records: Array.isArray(obj.records) ? obj.records : void 0,
+    schedules: Array.isArray(obj.schedules) ? obj.schedules : void 0,
+    secrets: Array.isArray(obj.secrets) ? obj.secrets : void 0
+  };
+}
 var FULL_PRODUCT_OBJECT_TEMPLATE_VERSION = "1.0";
 var FULL_PRODUCT_OBJECT_TEMPLATE_VERSION_1_1 = "1.1";
 var fpoTemplateVariableInputTypeSchema = external_exports.enum([
@@ -34798,9 +35055,6 @@ function getVariableReferences(template) {
   }
   return references;
 }
-function normalizeValidationPath(path16) {
-  return path16.map(String).join(".");
-}
 function coerceFPOTemplateVariableValue(variable, rawValue) {
   if (rawValue === void 0 || rawValue === null || rawValue === "") {
     return void 0;
@@ -34912,11 +35166,7 @@ function validateFPOTemplate(body, options = {}) {
   const parseResult = fullProductObjectTemplateSchema.safeParse(body);
   if (!parseResult.success) {
     const result2 = emptyResult();
-    result2.errors.push(
-      ...parseResult.error.issues.map(
-        (issue2) => createIssue("error", "SCHEMA_ERROR", issue2.message, normalizeValidationPath(issue2.path))
-      )
-    );
+    result2.errors.push(...zodIssuesToValidationIssues(parseResult.error.issues));
     result2.valid = false;
     return {
       ...result2,
@@ -57634,20 +57884,12 @@ function runValidation(body, kind) {
   }
   const parsed = fullProductObjectSchema.safeParse(body);
   if (!parsed.success) {
-    return {
-      kind,
-      valid: false,
-      errors: parsed.error.issues.map(
-        (issue2) => ({
-          code: "SCHEMA_ERROR",
-          message: issue2.message,
-          path: issue2.path.map(String).join("."),
-          severity: "error"
-        })
-      ),
-      warnings: [],
-      recommendations: []
-    };
+    const merged = mergeZodSchemaAndSemantic(
+      parsed,
+      coerceFullProductObjectForSemanticValidation(body),
+      validateFPO
+    );
+    return { kind, ...merged };
   }
   return { kind, ...validateFPO(parsed.data) };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/cli",
-  "version": "2.16.3",
+  "version": "2.16.5",
   "description": "Command-line interface for Runtype AI platform",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,7 @@
     "rosie-skills": "0.8.1",
     "yaml": "^2.8.3",
     "@runtypelabs/ink-components": "0.3.2",
-    "@runtypelabs/sdk": "4.0.1",
+    "@runtypelabs/sdk": "4.0.3",
     "@runtypelabs/terminal-animations": "0.2.1"
   },
   "devDependencies": {
@@ -36,7 +36,7 @@
     "tsx": "^4.7.1",
     "typescript": "^5.3.3",
     "vitest": "^4.1.0",
-    "@runtypelabs/shared": "1.8.0"
+    "@runtypelabs/shared": "1.9.0"
   },
   "engines": {
     "node": ">=22.0.0"