@elevasis/sdk 1.48.0 → 1.49.0

package/dist/index.js

@@ -65,44 +65,64 @@ var OntologyRecordBaseSchema = z.object({
 }).passthrough();
 var OntologyObjectTypeSchema = OntologyRecordBaseSchema.extend({
   properties: z.record(z.string().trim().min(1).max(200), z.unknown()).optional(),
-  storage: z.record(z.string(), z.unknown()).optional()
-});
+  storage: z.record(z.string(), z.unknown()).optional(),
+  // Carried by the legacy entity projection (`addLegacyEntityProjections`); not
+  // authored directly, but a real key an authored record must not collide with.
+  rowSchema: z.string().trim().min(1).optional(),
+  stateCatalogId: z.string().trim().min(1).optional()
+}).strict();
 var OntologyLinkTypeSchema = OntologyRecordBaseSchema.extend({
   from: OntologyIdSchema,
   to: OntologyIdSchema,
   cardinality: z.string().trim().min(1).max(80).optional(),
   via: z.string().trim().min(1).max(255).optional()
-});
+}).strict();
 var OntologyActionTypeSchema = OntologyRecordBaseSchema.extend({
   actsOn: OntologyReferenceListSchema,
   input: z.record(z.string().trim().min(1).max(200), z.unknown()).optional(),
-  effects: z.array(z.record(z.string(), z.unknown())).optional()
-});
+  effects: z.array(z.record(z.string(), z.unknown())).optional(),
+  resourceId: z.string().trim().min(1).optional(),
+  invocations: z.array(z.unknown()).optional(),
+  lifecycle: z.string().trim().min(1).optional(),
+  // Carried by the legacy action projection (`addLegacyActionProjections`); not
+  // authored directly, but a real key an authored record must not collide with.
+  legacyActionId: z.string().trim().min(1).optional()
+}).strict();
 var OntologyCatalogTypeSchema = OntologyRecordBaseSchema.extend({
   kind: z.string().trim().min(1).max(120).optional(),
   appliesTo: OntologyIdSchema.optional(),
-  entries: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
-});
+  entries: z.record(z.string().trim().min(1).max(200), z.unknown()).optional(),
+  // Carried by lead-gen's legacy stage-catalog projection
+  // (`createLeadGenStageCatalog`); not authored directly, but a real key an
+  // authored record must not collide with.
+  legacyCatalogKey: z.string().trim().min(1).optional(),
+  // Carried in live tenant configs (Elevasis, `nirvana-marketing`, and the
+  // `_template` scaffold all author these on `sales.crm:catalog/crm.pipeline`)
+  // as a cross-reference to the pre-ontology CRM pipeline key/entity id. No
+  // code currently reads them back — do not silently normalize them away.
+  legacyPipelineKey: z.string().trim().min(1).optional(),
+  legacyEntityKey: z.string().trim().min(1).optional()
+}).strict();
 var OntologyEventTypeSchema = OntologyRecordBaseSchema.extend({
   payload: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
-});
+}).strict();
 var OntologyInterfaceTypeSchema = OntologyRecordBaseSchema.extend({
   properties: z.record(z.string().trim().min(1).max(200), z.unknown()).optional()
-});
+}).strict();
 var OntologyValueTypeSchema = OntologyRecordBaseSchema.extend({
   primitive: z.string().trim().min(1).max(120).optional()
-});
+}).strict();
 var OntologySharedPropertySchema = OntologyRecordBaseSchema.extend({
   valueType: OntologyIdSchema.optional(),
   searchable: z.boolean().optional(),
   pii: z.boolean().optional()
-});
+}).strict();
 var OntologyGroupSchema = OntologyRecordBaseSchema.extend({
   members: OntologyReferenceListSchema
-});
+}).strict();
 var OntologyEndpointTypeSchema = OntologyRecordBaseSchema.extend({
   route: z.string().trim().min(1).max(500).optional()
-});
+}).strict();
 var OntologyScopeSchema = z.object({
   objectTypes: z.record(OntologyIdSchema, OntologyObjectTypeSchema).default({}).optional(),
   linkTypes: z.record(OntologyIdSchema, OntologyLinkTypeSchema).default({}).optional(),
@@ -3868,6 +3888,19 @@ var GPT5ConfigSchema = z.object({
   topP: z.number().min(0).max(1).optional(),
   modelOptions: GPT5OptionsSchema.optional()
 });
+var GPT56OptionsSchema = z.object({
+  reasoning_effort: z.enum(["none", "low", "medium", "high", "xhigh", "max"]).optional(),
+  verbosity: z.enum(["low", "medium", "high"]).optional()
+});
+var GPT56ConfigSchema = z.object({
+  model: z.enum(["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"]),
+  provider: z.enum(["openai"]),
+  apiKey: z.string(),
+  temperature: z.literal(1).optional(),
+  maxOutputTokens: z.number().min(4e3).optional(),
+  topP: z.number().min(0).max(1).optional(),
+  modelOptions: GPT56OptionsSchema.optional()
+});
 var MockConfigSchema = z.object({
   model: z.enum(["mock"]),
   provider: z.enum(["mock"]),
@@ -3920,9 +3953,12 @@ var AnthropicConfigSchema = z.discriminatedUnion("model", [
   AnthropicClaude5ConfigSchema,
   AnthropicStandardConfigSchema
 ]);
+var GPT56_CACHE_READ_RATE_MULTIPLIER = 0.1;
+var CACHE_CREATION_RATE_MULTIPLIER = 1.25;
 var MODEL_INFO = {
   // OpenAI GPT-5 (Reasoning Models)
   "gpt-5": {
+    provider: "openai",
     inputCostPer1M: 125,
     // $1.25 per 1M tokens
     outputCostPer1M: 1e3,
@@ -3936,6 +3972,7 @@ var MODEL_INFO = {
     configSchema: GPT5ConfigSchema
   },
   "gpt-5.4-mini": {
+    provider: "openai",
     inputCostPer1M: 75,
     // $0.75 per 1M tokens
     outputCostPer1M: 450,
@@ -3949,6 +3986,7 @@ var MODEL_INFO = {
     configSchema: GPT5ConfigSchema
   },
   "gpt-5.4-nano": {
+    provider: "openai",
     inputCostPer1M: 20,
     // $0.20 per 1M tokens
     outputCostPer1M: 125,
@@ -3960,8 +3998,60 @@ var MODEL_INFO = {
     category: "standard",
     configSchema: GPT5ConfigSchema
   },
+  // OpenAI GPT-5.6 family (GA 2026-07-09). All three tiers share 1.05M context, 128K max output,
+  // image input, tool use, structured outputs, and prompt caching -- they differ in reasoning depth
+  // and price, not capability. The bare `gpt-5.6` alias is deliberately unregistered; see OpenAIModel.
+  "gpt-5.6-sol": {
+    provider: "openai",
+    inputCostPer1M: 500,
+    // $5.00 per 1M tokens
+    outputCostPer1M: 3e3,
+    // $30.00 per 1M tokens
+    minTokens: 4e3,
+    recommendedTokens: 8e3,
+    maxTokens: 105e4,
+    // 1.05M context window
+    maxOutputTokens: 128e3,
+    category: "reasoning",
+    configSchema: GPT56ConfigSchema,
+    cacheReadRateMultiplier: GPT56_CACHE_READ_RATE_MULTIPLIER,
+    cacheCreationRateMultiplier: CACHE_CREATION_RATE_MULTIPLIER
+  },
+  "gpt-5.6-terra": {
+    provider: "openai",
+    inputCostPer1M: 250,
+    // $2.50 per 1M tokens
+    outputCostPer1M: 1500,
+    // $15.00 per 1M tokens
+    minTokens: 4e3,
+    recommendedTokens: 8e3,
+    maxTokens: 105e4,
+    // 1.05M context window
+    maxOutputTokens: 128e3,
+    category: "standard",
+    configSchema: GPT56ConfigSchema,
+    cacheReadRateMultiplier: GPT56_CACHE_READ_RATE_MULTIPLIER,
+    cacheCreationRateMultiplier: CACHE_CREATION_RATE_MULTIPLIER
+  },
+  "gpt-5.6-luna": {
+    provider: "openai",
+    inputCostPer1M: 100,
+    // $1.00 per 1M tokens
+    outputCostPer1M: 600,
+    // $6.00 per 1M tokens
+    minTokens: 4e3,
+    recommendedTokens: 8e3,
+    maxTokens: 105e4,
+    // 1.05M context window
+    maxOutputTokens: 128e3,
+    category: "standard",
+    configSchema: GPT56ConfigSchema,
+    cacheReadRateMultiplier: GPT56_CACHE_READ_RATE_MULTIPLIER,
+    cacheCreationRateMultiplier: CACHE_CREATION_RATE_MULTIPLIER
+  },
   // Mock model for testing
   mock: {
+    provider: "mock",
     inputCostPer1M: 0,
     // Free for tests
     outputCostPer1M: 0,
@@ -3975,6 +4065,7 @@ var MODEL_INFO = {
   },
   // OpenRouter Models (via openrouter.ai)
   "openrouter/z-ai/glm-5": {
+    provider: "openrouter",
     inputCostPer1M: 72,
     // $0.72 per 1M tokens
     outputCostPer1M: 230,
@@ -3988,6 +4079,7 @@ var MODEL_INFO = {
   },
   // Anthropic Claude Models (direct SDK access via @anthropic-ai/sdk)
   "claude-opus-5": {
+    provider: "anthropic",
     inputCostPer1M: 500,
     // $5.00 per 1M tokens
     outputCostPer1M: 2500,
@@ -4001,6 +4093,7 @@ var MODEL_INFO = {
     configSchema: AnthropicConfigSchema
   },
   "claude-sonnet-5": {
+    provider: "anthropic",
     // List pricing. An introductory rate of $2.00/$10.00 runs through 2026-08-31; encoding the
     // temporary rate would make historical cost analytics wrong once it lapses.
     inputCostPer1M: 300,
@@ -4016,6 +4109,7 @@ var MODEL_INFO = {
     configSchema: AnthropicConfigSchema
   },
   "claude-haiku-4-5-20251001": {
+    provider: "anthropic",
     inputCostPer1M: 100,
     // $1.00 per 1M tokens
     outputCostPer1M: 500,
@@ -4029,6 +4123,7 @@ var MODEL_INFO = {
     configSchema: AnthropicConfigSchema
   },
   "claude-haiku-4-5": {
+    provider: "anthropic",
     inputCostPer1M: 100,
     // $1.00 per 1M tokens
     outputCostPer1M: 500,
@@ -4048,7 +4143,7 @@ function getModelInfo(model) {
     return MODEL_INFO[model];
   }
   for (const knownModel of MODEL_KEYS_BY_SPECIFICITY) {
-    if (model.startsWith(knownModel)) {
+    if (model.startsWith(`${knownModel}-`)) {
       return MODEL_INFO[knownModel];
     }
   }
@@ -4420,13 +4515,126 @@ function buildIterationResponseSchemaUncached(tools, capabilities) {
   };
 }
 
+// ../core/src/execution/engine/workflow/types.ts
+var StepType2 = {
+  LINEAR: "linear",
+  CONDITIONAL: "conditional"
+};
+
+// ../core/src/execution/engine/workflow/errors.ts
+var WorkflowStepError = class extends ExecutionError2 {
+  type = "workflow_step_error";
+  severity = "critical";
+  category = "workflow";
+  /**
+   * @param cause - The error the step actually threw. Kept so the original stack and any
+   *   non-`ExecutionError` throw survive the wrap; its classification is additionally copied into
+   *   `context` by the caller, because `type`/`severity`/`category` are fixed on this class.
+   */
+  constructor(message, context, cause) {
+    super(message, context);
+    if (cause !== void 0) this.cause = cause;
+  }
+};
+var WorkflowValidationError = class extends ExecutionError2 {
+  type = "workflow_validation_error";
+  severity = "info";
+  category = "validation";
+  constructor(message, context) {
+    super(message, context);
+  }
+};
+
+// ../core/src/execution/engine/workflow/utils.ts
+function validateEntryPoint(steps, entryPoint) {
+  if (!(entryPoint in steps)) {
+    throw new WorkflowValidationError(`Entry point step '${entryPoint}' not found in workflow`, {
+      entryPoint
+    });
+  }
+}
+function findTerminalSteps(steps) {
+  return Object.values(steps).filter((step) => step.next === null);
+}
+function validateTerminalSteps(steps, workflowId) {
+  const terminalSteps = findTerminalSteps(steps);
+  if (terminalSteps.length === 0) {
+    throw new WorkflowValidationError(`Workflow '${workflowId}' must have at least one terminal step (next: null)`, {
+      workflowId
+    });
+  }
+}
+function validateStepReferences(steps) {
+  for (const [id, step] of Object.entries(steps)) {
+    if (step.next === null) {
+      continue;
+    }
+    if (step.next.type === StepType2.LINEAR) {
+      if (!(step.next.target in steps)) {
+        throw new WorkflowValidationError(`Step '${id}' references non-existent target '${step.next.target}'`, {
+          stepId: id,
+          target: step.next.target
+        });
+      }
+    } else if (step.next.type === StepType2.CONDITIONAL) {
+      const targets = [...step.next.routes.map((r) => r.target), step.next.default];
+      for (const target of targets) {
+        if (!(target in steps)) {
+          throw new WorkflowValidationError(`Step '${id}' references non-existent target '${target}'`, {
+            stepId: id,
+            target
+          });
+        }
+      }
+    }
+  }
+}
+function detectCycle(visited, executionPath, currentStepId) {
+  if (visited.has(currentStepId)) {
+    const cycle = executionPath.slice(executionPath.indexOf(currentStepId));
+    throw new WorkflowStepError(`Cycle detected in workflow: ${cycle.join(" -> ")} -> ${currentStepId}`, {
+      stepId: currentStepId,
+      cycle: [...cycle, currentStepId]
+    });
+  }
+}
+function validateWorkflowGraph(steps, entryPoint, workflowId) {
+  const onPath = /* @__PURE__ */ new Set();
+  const executionPath = [];
+  const reached = /* @__PURE__ */ new Set();
+  const walk = (stepId) => {
+    detectCycle(onPath, executionPath, stepId);
+    onPath.add(stepId);
+    executionPath.push(stepId);
+    reached.add(stepId);
+    const step = steps[stepId];
+    if (step && step.next !== null) {
+      const targets = step.next.type === StepType2.LINEAR ? [step.next.target] : [...step.next.routes.map((route) => route.target), step.next.default];
+      for (const target of targets) {
+        if (target in steps) walk(target);
+      }
+    }
+    executionPath.pop();
+    onPath.delete(stepId);
+  };
+  if (entryPoint in steps) walk(entryPoint);
+  const orphanIds = Object.keys(steps).filter((id) => !reached.has(id));
+  if (orphanIds.length > 0) {
+    throw new WorkflowValidationError(
+      `Workflow '${workflowId}' has step(s) unreachable from entry point '${entryPoint}': ${orphanIds.join(", ")}`,
+      { workflowId, entryPoint, orphanIds }
+    );
+  }
+}
+
 // ../core/src/platform/registry/validation.ts
 var RegistryValidationError = class extends Error {
-  constructor(orgName, resourceId, field, message) {
+  constructor(orgName, resourceId, field, message, issues) {
     super(message);
     this.orgName = orgName;
     this.resourceId = resourceId;
     this.field = field;
+    this.issues = issues;
     this.name = "RegistryValidationError";
   }
 };
@@ -4447,7 +4655,14 @@ function emitGovernanceIssues(issues, mode, onWarning) {
   if (issues.length === 0) return;
   if (mode === "strict") {
     const first = issues[0];
-    throw new RegistryValidationError(first.orgName, first.resourceId, "organizationModel.resources", first.message);
+    const messages = issues.map((issue) => issue.message);
+    throw new RegistryValidationError(
+      first.orgName,
+      first.resourceId,
+      "organizationModel.resources",
+      messages.join("\n"),
+      messages
+    );
   }
   const warn = onWarning ?? ((issue) => console.warn(issue.message));
   for (const issue of issues) {
@@ -4608,7 +4823,7 @@ function addTopologyIssues(issues, orgName, deployment, organizationModel, syste
     if (ref.kind === "humanCheckpoint") return humanCheckpointIds.has(ref.id);
     if (ref.kind === "externalResource") return externalResourceIds.has(ref.id);
     if (ref.kind === "ontology") {
-      if (ontologyIndex === void 0) return true;
+      if (ontologyIndex === void 0) return false;
       return Object.values(ontologyIndex).some((records) => records[ref.id] !== void 0);
     }
     return false;
@@ -4766,7 +4981,8 @@ function addSystemInterfaceIssue(issues, orgName, systemPath, interfaceKey, issu
     message: `[${orgName}] ${issue.family}:${issue.code}: ${issue.message}`
   });
 }
-function validateDeclaredSystemInterfaceReadiness(orgName, organizationModel) {
+function validateDeclaredSystemInterfaceReadiness(orgName, organizationModel, options = {}) {
+  const mode = getResourceValidatorMode(options.mode);
   const issues = [];
   if (organizationModel === void 0) return { valid: true, issues };
   const model = organizationModel;
@@ -4792,17 +5008,27 @@ function validateDeclaredSystemInterfaceReadiness(orgName, organizationModel) {
     }
   }
   if (issues.length > 0) {
-    const first = issues[0];
-    throw new RegistryValidationError(
-      first.orgName,
-      `${first.systemPath}/${first.interfaceKey}`,
-      first.path ?? "organizationModel.systems.apiInterface",
-      first.message
-    );
+    if (mode === "strict") {
+      const first = issues[0];
+      const messages = issues.map((issue) => issue.message);
+      throw new RegistryValidationError(
+        first.orgName,
+        `${first.systemPath}/${first.interfaceKey}`,
+        first.path ?? "organizationModel.systems.apiInterface",
+        messages.join("\n"),
+        messages
+      );
+    }
+    const warn = options.onWarning ?? ((issue) => console.warn(issue.message));
+    for (const issue of issues) {
+      warn(issue);
+    }
+    return { valid: false, issues };
   }
   return { valid: true, issues };
 }
-function validateDeploymentSpec(orgName, resources) {
+function validateDeploymentSpec(orgName, resources, options = {}) {
+  const warn = options.onWarning ?? ((message) => console.warn(message));
   const seenIds = /* @__PURE__ */ new Set();
   resources.workflows?.forEach((workflow) => {
     const id = workflow.config.resourceId;
@@ -4821,6 +5047,14 @@ function validateDeploymentSpec(orgName, resources) {
     if (workflow.interface) {
       validateExecutionInterface(orgName, id, workflow.interface, workflow.contract.inputSchema);
     }
+    try {
+      validateEntryPoint(workflow.steps, workflow.entryPoint);
+      validateTerminalSteps(workflow.steps, id);
+      validateStepReferences(workflow.steps);
+      validateWorkflowGraph(workflow.steps, workflow.entryPoint, id);
+    } catch (error) {
+      warn(`[${orgName}] Workflow '${id}' graph validation: ${error instanceof Error ? error.message : String(error)}`);
+    }
   });
   resources.agents?.forEach((agent) => {
     const id = agent.config.resourceId;
@@ -4834,14 +5068,20 @@ function validateDeploymentSpec(orgName, resources) {
     }
     seenIds.add(id);
     validateResourceModelConfig(orgName, id, agent.modelConfig);
-    validateAgentGrammar(orgName, id, agent);
-    validateAgentCheapAssertions(orgName, id, agent);
+    validateAgentGrammar(orgName, id, agent, options.mode);
+    validateAgentCheapAssertions(orgName, id, agent, options.mode);
     if (agent.interface) {
       validateExecutionInterface(orgName, id, agent.interface, agent.contract.inputSchema);
     }
   });
-  validateResourceGovernance(orgName, resources);
-  validateDeclaredSystemInterfaceReadiness(orgName, resources.organizationModel);
+  validateResourceGovernance(orgName, resources, void 0, {
+    mode: options.mode,
+    onWarning: (issue) => warn(issue.message)
+  });
+  validateDeclaredSystemInterfaceReadiness(orgName, resources.organizationModel, {
+    mode: options.mode,
+    onWarning: (issue) => warn(issue.message)
+  });
 }
 function validateResourceModelConfig(orgName, resourceId, modelConfig) {
   try {
@@ -4916,7 +5156,7 @@ function describeGrammarRefusal(reasons, toolInputSchema) {
   }
   return `refused strict mode: ${reasons.join(", ")}`;
 }
-function validateAgentGrammar(orgName, agentId, agent) {
+function validateAgentGrammar(orgName, agentId, agent, mode) {
   const dialect = dialectForProvider(agent.modelConfig.provider);
   if (!dialect) return;
   const capabilities = agentCapabilitiesForGrammarCheck(agent.config);
@@ -4937,12 +5177,12 @@ function validateAgentGrammar(orgName, agentId, agent) {
     compileSchema(offending.inputSchema, dialect).refusalReasons,
     offending.inputSchema
   )}. This silently drops strict-mode enforcement for the agent's ENTIRE iteration schema on every call, not just this tool -- compileSchema refuses whole-schema, never per-tool.` : `[${orgName}] Agent '${agentId}' iteration schema refused strict mode for provider '${agent.modelConfig.provider}': ${compiled.refusalReasons.join(", ")}. No single tool is independently responsible -- this is a whole-schema limit (e.g. total optional properties across every tool exceeding the provider's cap).`;
-  if (getResourceValidatorMode() === "strict") {
+  if (getResourceValidatorMode(mode) === "strict") {
     throw new RegistryValidationError(orgName, agentId, "tools", message);
   }
   console.warn(message);
 }
-function validateAgentCheapAssertions(orgName, agentId, agent) {
+function validateAgentCheapAssertions(orgName, agentId, agent, mode) {
   const issues = [];
   const config = agent.config;
   if (config.sessionCapable && config.securityLevel === "none") {
@@ -4972,7 +5212,7 @@ function validateAgentCheapAssertions(orgName, agentId, agent) {
   }
   if (issues.length === 0) return;
   const message = `[${orgName}] Agent '${agentId}': ${issues.join(" ")}`;
-  if (getResourceValidatorMode() === "strict") {
+  if (getResourceValidatorMode(mode) === "strict") {
     throw new RegistryValidationError(orgName, agentId, "config", message);
   }
   console.warn(message);
@@ -5228,12 +5468,6 @@ function validateHumanCheckpoints(orgName, humanCheckpoints, allInternalIds, val
   });
 }
 
-// ../core/src/execution/engine/workflow/types.ts
-var StepType2 = {
-  LINEAR: "linear",
-  CONDITIONAL: "conditional"
-};
-
 // ../core/src/execution/engine/base/serialization.ts
 function serializeDefinition(definition, options) {
   const opts = {