@elevasis/sdk 1.54.0 → 1.56.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Elevasis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+# @elevasis/sdk
+
+SDK for building Elevasis organization resources — agents, workflows, and the CLI that deploys them.
+
+## Install
+
+```sh
+pnpm add @elevasis/sdk
+```
+
+## Published surface
+
+| Subpath                      | Contains                                                                  |
+| ---------------------------- | ------------------------------------------------------------------------- |
+| `@elevasis/sdk`              | Resource definitions, the registry, and its validators                    |
+| `@elevasis/sdk/worker`       | The worker-thread authoring surface: `Agent`, `Workflow`, collectors      |
+| `@elevasis/sdk/node`         | Node-only helpers                                                         |
+| `@elevasis/sdk/test-utils`   | Test helpers for resource authors                                         |
+
+The package also installs an `elevasis-sdk` binary. Run `elevasis-sdk --help` for the command set;
+every authenticated command accepts `--prod` to target production rather than a local API.
+
+## Relationship to `@elevasis/core`
+
+The SDK inlines the `@repo/core` types it re-exports, so no `@elevasis/core` specifier survives in
+the shipped declarations. That makes the SDK a second sanctioned route onto capabilities core does
+not publish directly — import them from here rather than reaching for a core subpath that does not
+resolve.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/{chunk-ZAVFBZHM.js → chunk-72ZGICTR.js}

@@ -1,4 +1,4 @@
-import { ProcessingStageStatusSchema, ListBuilderStageKeySchema, LLMResponseParseError, errorToString, getErrorDetails, ExecutionError2, validateEntryPoint, validateTerminalSteps, validateStepReferences, WorkflowTimeoutError, WorkflowStalledError, WorkflowCancellationError, logWorkflowStart, detectCycle, WorkflowStepError, logStepStart, validateTerminalOutput, logStepSuccess, determineNextStep, logStepFailure, logExecutionPath, logWorkflowSuccess, logWorkflowFailure, estimateTokens, allSettledWithConcurrency, truncationCharBudget, buildIterationResponseSchema } from './chunk-OT4CHFQJ.js';
+import { ProcessingStageStatusSchema, ListBuilderStageKeySchema, LLMResponseParseError, errorToString, getErrorDetails, ExecutionError2, validateEntryPoint, validateTerminalSteps, validateStepReferences, WorkflowTimeoutError, WorkflowStalledError, WorkflowCancellationError, WorkflowStepTimeoutError, logWorkflowStart, detectCycle, WorkflowStepError, logStepStart, validateTerminalOutput, logStepSuccess, determineNextStep, logStepFailure, logExecutionPath, logWorkflowSuccess, logWorkflowFailure, estimateTokens, allSettledWithConcurrency, calculateCost, truncationCharBudget, buildIterationResponseSchema } from './chunk-R3J6BEPO.js';
 import { workerData, parentPort } from 'worker_threads';
 import { zodToJsonSchema } from '@alcyone-labs/zod-to-json-schema';
 import { z, ZodError } from 'zod';
@@ -65,6 +65,71 @@ var Workflow = class {
     }
     return new WorkflowCancellationError("Execution cancelled by user", { stepId, executionPath });
   }
+  /**
+   * Run one step's handler, bounded by the step's own `timeout` when it declares one.
+   *
+   * Two things have to happen for a step deadline to mean anything, and doing only one of them is
+   * why this is not a bare `Promise.race`:
+   *
+   * 1. The handler is handed a context whose `signal` is the step's, chained off the execution's, so
+   *    a handler that already honours `context.signal` (every `fetch`-based one does) aborts its own
+   *    work at the step deadline instead of running on unattended.
+   * 2. The race rejects regardless, because a handler that ignores its signal would otherwise hold
+   *    the graph open until the 2-hour execution ceiling -- which is the whole thing being fixed.
+   *
+   * The chaining direction matches `startExecutionDeadline` in the API's `lifecycle.ts`: the parent's
+   * abort reason is propagated verbatim into the child controller, so an execution-level cancel or
+   * timeout still classifies as itself rather than as a step deadline.
+   *
+   * A step with no `timeout` takes the untouched path and is handed `context` itself -- no derived
+   * controller, no listener, no race.
+   */
+  async runStepHandler(step, input, context, executionPath) {
+    if (step.timeout === void 0) return step.handler(input, context);
+    const controller = new AbortController();
+    let deadlineFired = false;
+    const timer = setTimeout(() => {
+      deadlineFired = true;
+      controller.abort("timeout");
+    }, step.timeout);
+    let onParentAbort;
+    if (context.signal) {
+      if (context.signal.aborted) {
+        controller.abort(context.signal.reason);
+      } else {
+        onParentAbort = () => controller.abort(context.signal?.reason);
+        context.signal.addEventListener("abort", onParentAbort, { once: true });
+      }
+    }
+    const aborted = new Promise((_, reject) => {
+      controller.signal.addEventListener(
+        "abort",
+        () => {
+          if (deadlineFired) {
+            reject(
+              new WorkflowStepTimeoutError(`Step exceeded its timeout (${step.timeout}ms) [${step.id}:${step.name}]`, {
+                timeout: step.timeout,
+                stepId: step.id,
+                stepName: step.name,
+                executionPath
+              })
+            );
+            return;
+          }
+          reject(
+            this.abortErrorFor(context.signal, step.id, executionPath) ?? new WorkflowCancellationError("Execution cancelled by user", { stepId: step.id, executionPath })
+          );
+        },
+        { once: true }
+      );
+    });
+    try {
+      return await Promise.race([step.handler(input, { ...context, signal: controller.signal }), aborted]);
+    } finally {
+      clearTimeout(timer);
+      if (onParentAbort) context.signal?.removeEventListener("abort", onParentAbort);
+    }
+  }
   /**
    * Execute the workflow with graph-based flow control
    * Context is required for execution tracking, logging, and organization isolation
@@ -98,7 +163,7 @@ var Workflow = class {
         logStepStart(context, step.id, step.name, currentData, stepStartTime);
         try {
           const validatedInput = step.inputSchema.parse(currentData);
-          const rawOutput = await step.handler(validatedInput, context);
+          const rawOutput = await this.runStepHandler(step, validatedInput, context, executionPath);
           currentData = step.outputSchema.parse(rawOutput);
           if (step.next === null && this.shouldGenerateOutput) {
             validateTerminalOutput(step.id, currentData, this.contract.outputSchema);
@@ -120,6 +185,9 @@ var Workflow = class {
           const stepEndTime = Date.now();
           const duration = stepEndTime - stepStartTime;
           logStepFailure(context, step.id, step.name, error, duration, stepStartTime, stepEndTime);
+          if (error instanceof WorkflowStepTimeoutError || error instanceof WorkflowTimeoutError || error instanceof WorkflowStalledError || error instanceof WorkflowCancellationError) {
+            throw error;
+          }
           const cause = error instanceof ExecutionError2 ? error : void 0;
           throw new WorkflowStepError(
             `Step failed [${step.id}:${step.name}]: ${errorToString(error)}`,
@@ -1255,6 +1323,12 @@ function normalizeSessionMessages(actions, sessionCapable) {
 }
 var NO_PROGRESS_STREAK_KEY = "agent.actions.noProgressStreak";
 var MAX_CONSECUTIVE_NO_PROGRESS_ITERATIONS = 2;
+var LAST_PLAN_SIGNATURE_KEY = "agent.actions.lastPlanSignature";
+var REPEATED_PLAN_STREAK_KEY = "agent.actions.repeatedPlanStreak";
+var DEFAULT_MAX_IDENTICAL_ITERATIONS = 3;
+function planSignature(actions) {
+  return JSON.stringify(actions);
+}
 async function processActions(iterationContext, response) {
   const normalizedActions = normalizeSessionMessages(response.nextActions, !!iterationContext.config.sessionCapable);
   if (normalizedActions.length === 0) {
@@ -1278,6 +1352,31 @@ async function processActions(iterationContext, response) {
     }
   } else {
     iterationContext.executionContext.store.delete(NO_PROGRESS_STREAK_KEY);
+    const store = iterationContext.executionContext.store;
+    const signature = planSignature(normalizedActions);
+    const repeated = store.get(LAST_PLAN_SIGNATURE_KEY) === signature;
+    const streak = repeated ? (store.get(REPEATED_PLAN_STREAK_KEY) ?? 0) + 1 : 0;
+    store.set(LAST_PLAN_SIGNATURE_KEY, signature);
+    store.set(REPEATED_PLAN_STREAK_KEY, streak);
+    if (repeated) {
+      const ceiling = iterationContext.config.constraints?.maxIdenticalIterations ?? DEFAULT_MAX_IDENTICAL_ITERATIONS;
+      iterationContext.memoryManager.addToHistory({
+        type: "error",
+        content: JSON.stringify({
+          error: `This iteration's plan is identical to the previous one (repeated ${streak}x). Repeating it again will produce the same result. Either act on what the last result returned, or complete.`
+        }),
+        turnNumber: iterationContext.executionContext.sessionTurnNumber ?? null,
+        iterationNumber: iterationContext.iteration,
+        source: "framework"
+      });
+      if (streak >= ceiling) {
+        throw new AgentNoProgressError(`Agent repeated an identical plan for ${streak} consecutive iterations`, {
+          iteration: iterationContext.iteration,
+          streak,
+          ceiling
+        });
+      }
+    }
   }
   const completeRequested = normalizedActions.some((action) => action.type === "complete");
   const toolCalls = [];
@@ -2139,6 +2238,14 @@ var Agent = class {
     while (iteration <= maxIterations) {
       const abortError = this.abortErrorFor(context.signal, iteration);
       if (abortError) throw abortError;
+      const spendStop = this.spendCeilingReached(context);
+      if (spendStop) {
+        context.logger.warn(
+          `Agent stopped at iteration ${iteration}: ${spendStop.limit} ceiling of ${spendStop.ceiling} reached (${spendStop.actual})`
+        );
+        this.stopReason = "spend_exhausted";
+        return;
+      }
       try {
         await context.onHeartbeat?.();
       } catch {
@@ -2162,6 +2269,33 @@ var Agent = class {
     }
     this.stopReason = "budget_exhausted";
   }
+  /**
+   * Whether a declared spend ceiling has been reached, and which one.
+   *
+   * Reads `ExecutionContext.aiUsageCollector` -- the same collector `ObservabilityService` persists
+   * to `execution_metrics` -- so enforcement and the recorded figure can never disagree. The
+   * collector was already being written on every LLM call and read only after the fact; this is the
+   * first place its running total decides anything.
+   *
+   * Returns `null` when no ceiling is declared, or when no collector was injected. An execution
+   * without a collector is not silently capped at zero -- it is uncapped, which is what it was
+   * before any of this existed.
+   *
+   * @returns the breached ceiling, or `null` when none is.
+   */
+  spendCeilingReached(context) {
+    const { maxCostUsd, maxTotalTokens } = this.config.constraints ?? {};
+    if (maxCostUsd === void 0 && maxTotalTokens === void 0) return null;
+    const summary = context.aiUsageCollector?.getSummary();
+    if (!summary) return null;
+    if (maxCostUsd !== void 0 && summary.totalCostUsd >= maxCostUsd) {
+      return { limit: "maxCostUsd", ceiling: maxCostUsd, actual: summary.totalCostUsd };
+    }
+    if (maxTotalTokens !== void 0 && summary.totalTokens >= maxTotalTokens) {
+      return { limit: "maxTotalTokens", ceiling: maxTotalTokens, actual: summary.totalTokens };
+    }
+    return null;
+  }
   /**
    * Classify an aborted signal into the typed error the rest of the framework expects, regardless
    * of where the abort surfaced. An abort landing mid-`fetch` or mid-tool throws whatever the
@@ -2589,6 +2723,78 @@ Fix the errors and generate a valid output.
     }
   }
 };
+
+// ../core/src/operations/observability/ai-usage-collector.ts
+var AIUsageCollector = class {
+  model = "gpt-5";
+  // Default, will be overwritten on first record()
+  calls = [];
+  callSequence = 0;
+  /**
+   * Record a single AI call with usage metrics
+   *
+   * @param usage - Token usage and latency data from LLM adapter
+   * @param callType - Type discriminator (agent-reasoning, tool, etc.)
+   * @param context - Optional typed context specific to callType
+   */
+  record(usage, callType = "other", context) {
+    this.callSequence++;
+    this.model = usage.model;
+    const costUsd = usage.cost ?? calculateCost(
+      usage.model,
+      usage.inputTokens,
+      usage.outputTokens,
+      usage.cacheReadInputTokens,
+      usage.cacheCreationInputTokens
+    );
+    const inputTokens = usage.inputTokens + (usage.cacheReadInputTokens ?? 0) + (usage.cacheCreationInputTokens ?? 0);
+    this.calls.push({
+      callSequence: this.callSequence,
+      callType,
+      model: usage.model,
+      inputTokens,
+      outputTokens: usage.outputTokens,
+      costUsd,
+      latencyMs: usage.latencyMs,
+      context,
+      ...usage.cacheReadInputTokens !== void 0 ? { cacheReadInputTokens: usage.cacheReadInputTokens } : {},
+      ...usage.cacheCreationInputTokens !== void 0 ? { cacheCreationInputTokens: usage.cacheCreationInputTokens } : {},
+      ...usage.inputWarnings?.length ? { inputWarnings: usage.inputWarnings } : {},
+      ...usage.inputWarningsBySource?.length ? { inputWarningsBySource: usage.inputWarningsBySource } : {},
+      ...usage.inputBlocked ? { inputBlocked: true } : {},
+      ...usage.outputValidationError ? { outputValidationError: usage.outputValidationError } : {},
+      ...usage.unvalidatedOutput ? { unvalidatedOutput: usage.unvalidatedOutput } : {},
+      ...usage.strictStatus ? { strictStatus: usage.strictStatus } : {},
+      ...usage.strictRefusalReasons?.length ? { strictRefusalReasons: usage.strictRefusalReasons } : {},
+      ...usage.providerMs !== void 0 ? { providerMs: usage.providerMs } : {},
+      ...usage.validateMs !== void 0 ? { validateMs: usage.validateMs } : {},
+      ...usage.wallClockMs !== void 0 ? { wallClockMs: usage.wallClockMs } : {}
+    });
+  }
+  /**
+   * Get aggregated summary of all AI calls
+   */
+  getSummary() {
+    const totalInputTokens = this.calls.reduce((sum, c) => sum + c.inputTokens, 0);
+    const totalOutputTokens = this.calls.reduce((sum, c) => sum + c.outputTokens, 0);
+    const totalCostUsd = this.calls.reduce((sum, c) => sum + c.costUsd, 0);
+    return {
+      model: this.model,
+      totalInputTokens,
+      totalOutputTokens,
+      totalTokens: totalInputTokens + totalOutputTokens,
+      totalCostUsd,
+      callCount: this.calls.length,
+      calls: this.calls
+    };
+  }
+  /**
+   * Check if any usage has been recorded
+   */
+  hasUsage() {
+    return this.calls.length > 0;
+  }
+};
 var RETRYABLE_CODES = /* @__PURE__ */ new Set([
   "rate_limit_exceeded",
   "network_error",
@@ -2756,11 +2962,14 @@ var platform = {
 
 // src/worker/llm-adapter.ts
 var PostMessageLLMAdapter = class {
-  constructor(provider, model) {
+  constructor(provider, model, aiUsageCollector, callType) {
     this.provider = provider;
     this.model = model;
+    this.aiUsageCollector = aiUsageCollector;
+    this.callType = callType;
   }
   async generate(request) {
+    const startedAt = Date.now();
     const { result, usage } = await platform.callWithUsage({
       tool: "llm",
       method: "generate",
@@ -2777,6 +2986,22 @@ var PostMessageLLMAdapter = class {
         maxOutputTokens: request.maxOutputTokens
       }
     });
+    if (usage && this.aiUsageCollector) {
+      this.aiUsageCollector.record(
+        {
+          model: usage.model ?? this.model,
+          inputTokens: usage.inputTokens,
+          outputTokens: usage.outputTokens,
+          latencyMs: Date.now() - startedAt,
+          ...usage.cost !== void 0 && { cost: usage.cost },
+          ...usage.cacheReadInputTokens !== void 0 && { cacheReadInputTokens: usage.cacheReadInputTokens },
+          ...usage.cacheCreationInputTokens !== void 0 && {
+            cacheCreationInputTokens: usage.cacheCreationInputTokens
+          }
+        },
+        this.callType
+      );
+    }
     return {
       output: result,
       ...usage && {
@@ -2791,10 +3016,11 @@ var PostMessageLLMAdapter = class {
   }
 };
 function createPostMessageAdapterFactory() {
-  return (config) => new PostMessageLLMAdapter(config.provider, config.model);
+  return (config, aiUsageCollector, callType) => new PostMessageLLMAdapter(config.provider, config.model, aiUsageCollector, callType);
 }
+var FULL_TOKEN_HEX_LENGTH = 32;
 function generateHmacToken(secret, data) {
-  return createHmac("sha256", secret).update(data.toLowerCase().trim()).digest("hex").slice(0, 16);
+  return createHmac("sha256", secret).update(data.toLowerCase().trim()).digest("hex").slice(0, FULL_TOKEN_HEX_LENGTH);
 }
 function classifyPlatformToolError(err, options = {}) {
   const {
@@ -4244,6 +4470,12 @@ function buildWorkerExecutionContext(params) {
     organizationId: params.organizationId,
     organizationName: params.organizationName,
     resourceId: params.resourceId,
+    // Worker-side usage accounting. The parent keeps its own collector and remains the source of the
+    // persisted `execution_metrics` row; this one exists so the agent loop — which runs in this
+    // thread — can read what the turn has spent so far and stop at a declared ceiling. Without it
+    // `Agent.iterate` read `undefined` on every deployed execution and treated every agent as
+    // uncapped, which a local dogfood run on 2026-09-02 is what caught.
+    aiUsageCollector: new AIUsageCollector(),
     sessionId: params.sessionId,
     sessionTurnNumber: params.sessionTurnNumber,
     conversationHistory: params.conversationHistory,
@@ -4450,19 +4682,28 @@ function startWorker(org) {
           const durationMs = Date.now() - startTime;
           const stopReason = agentInstance.getStopReason();
           const budgetExhausted = stopReason === "budget_exhausted";
+          const spendExhausted = stopReason === "spend_exhausted";
+          const stoppedShort = budgetExhausted || spendExhausted;
           if (budgetExhausted) {
             console.warn(`[SDK-WORKER] Agent '${resourceId}' exhausted its iteration budget (${durationMs}ms)`);
+          } else if (spendExhausted) {
+            console.warn(`[SDK-WORKER] Agent '${resourceId}' reached its cost/token ceiling (${durationMs}ms)`);
           } else {
             console.log(`[SDK-WORKER] Agent '${resourceId}' completed (${durationMs}ms)`);
           }
           parentPort.postMessage({
             type: "result",
-            status: budgetExhausted ? "failed" : "completed",
+            status: stoppedShort ? "failed" : "completed",
             ...budgetExhausted ? {
               error: "Agent stopped without completing: iteration budget exhausted. Any output below was synthesized from partial work.",
               errorName: "AgentBudgetExhaustedError",
               errorCode: "agent_budget_exhausted"
             } : {},
+            ...spendExhausted ? {
+              error: "Agent stopped without completing: cost or token ceiling reached. Any output below was synthesized from partial work.",
+              errorName: "AgentSpendExhaustedError",
+              errorCode: "agent_spend_exhausted"
+            } : {},
             output,
             stopReason,
             // Whether the agent emitted an assistant message this turn. `Agent` has tracked this for

package/dist/{chunk-OT4CHFQJ.js → chunk-R3J6BEPO.js}

@@ -814,14 +814,25 @@ var SystemEntrySchema = z.object({
    * position-derived paths. Both still exist on this schema for backward compat.
    */
   systems: z.lazy(() => z.record(z.string().trim().min(1).max(100), SystemEntrySchema)).optional(),
-  /** @deprecated Use systems. Accepted as a compatibility alias during the ontology bridge. */
+  /**
+   * @deprecated Use systems. Accepted as a compatibility alias during the ontology bridge.
+   *
+   * Accepted on INPUT only. Parsing used to mirror `systems` into this key so that
+   * either spelling could be read off a parsed model, which meant every parsed System
+   * carried the same children twice. Readers that walked both keys then visited each
+   * nested System twice -- `getOrgOsRouteContractSystems` reported 11 checked paths
+   * against command-center's 7 real Systems and would have raised every nested-System
+   * failure as two failures -- and readers that walked this key alone looked correct
+   * while depending entirely on the mirror. Both defects were live. The mirror is gone:
+   * a parsed model now carries children under whichever key the author wrote, so read
+   * `system.systems ?? system.subsystems` (helpers.ts, validation.ts, ontology.ts,
+   * selectDeclaredSystems.ts, validateManifests.ts and SystemOpsView.tsx all do).
+   */
   subsystems: z.lazy(() => z.record(z.string().trim().min(1).max(100), SystemEntrySchema)).optional()
 }).strict().refine((system) => system.label !== void 0 || system.title !== void 0, {
   path: ["label"],
   message: "System must provide label or title"
-}).transform(
-  (system) => system.systems !== void 0 && system.subsystems === void 0 ? { ...system, subsystems: system.systems } : system
-);
+});
 z.record(z.string(), SystemEntrySchema).refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
   message: "Each system entry id must match its map key"
 }).default({});
@@ -1992,6 +2003,8 @@ var AnthropicConfigSchema = z.discriminatedUnion("model", [
   AnthropicClaude5ConfigSchema,
   AnthropicStandardConfigSchema
 ]);
+var ANTHROPIC_CACHE_READ_RATE_MULTIPLIER = 0.1;
+var OPENAI_CACHE_READ_RATE_MULTIPLIER = 0.5;
 var GPT56_CACHE_READ_RATE_MULTIPLIER = 0.1;
 var CACHE_CREATION_RATE_MULTIPLIER = 1.25;
 var MODEL_INFO = {
@@ -2188,6 +2201,30 @@ function getModelInfo(model) {
   }
   return void 0;
 }
+function cacheReadRateMultiplier(model, info) {
+  if (info?.cacheReadRateMultiplier !== void 0) return info.cacheReadRateMultiplier;
+  return model.startsWith("claude-") ? ANTHROPIC_CACHE_READ_RATE_MULTIPLIER : OPENAI_CACHE_READ_RATE_MULTIPLIER;
+}
+function cacheCreationRateMultiplier(info) {
+  return info?.cacheCreationRateMultiplier ?? CACHE_CREATION_RATE_MULTIPLIER;
+}
+function calculateCost(model, inputTokens, outputTokens, cacheReadInputTokens = 0, cacheCreationInputTokens = 0) {
+  const info = getModelInfo(model);
+  if (!info) {
+    console.warn(
+      `[CostCalculator] Unknown model '${model}' - cannot calculate cost. Available models:`,
+      Object.keys(MODEL_INFO)
+    );
+    return 0;
+  }
+  const baseInputRate = info.inputCostPer1M / 100;
+  const inputCostUsd = inputTokens / 1e6 * baseInputRate;
+  const cacheReadCostUsd = cacheReadInputTokens / 1e6 * baseInputRate * cacheReadRateMultiplier(model, info);
+  const cacheCreationCostUsd = cacheCreationInputTokens / 1e6 * baseInputRate * cacheCreationRateMultiplier(info);
+  const outputCostUsd = outputTokens / 1e6 * (info.outputCostPer1M / 100);
+  const totalCostUsd = inputCostUsd + cacheReadCostUsd + cacheCreationCostUsd + outputCostUsd;
+  return totalCostUsd;
+}
 function validateModelConfig(config) {
   const model = config.model;
   if (!model) {
@@ -2615,6 +2652,18 @@ var WorkflowTimeoutError = class extends ExecutionError2 {
     return false;
   }
 };
+var WorkflowStepTimeoutError = class extends ExecutionError2 {
+  type = "workflow_step_timeout_error";
+  severity = "critical";
+  category = "workflow";
+  constructor(message, context) {
+    super(message, context);
+  }
+  /** The run still had budget; a slow dependency is exactly the case a retry exists for. */
+  isRetryable() {
+    return true;
+  }
+};
 var WorkflowStalledError = class extends ExecutionError2 {
   type = "workflow_stalled_error";
   severity = "critical";
@@ -5962,4 +6011,4 @@ function defineWorkflowConfig(resourceId, descriptors, actionRegistry = []) {
 }
 var ListBuilderStageKeySchema = z.string().min(1);
 
-export { ActivityEventSchema, BuildPlanSnapshotStepSchema, ContractRefResolutionError, CrmStageKeySchema, CrmStateKeySchema, EmailSchema, ExecutionError, ExecutionError2, LLMResponseParseError, ListBuilderStageKeySchema, ProcessingStageStatusSchema, ProspectingBuildTemplateSchema, RegistryValidationError, ResourceRegistry, StepType, ToolingError, WorkflowCancellationError, WorkflowStalledError, WorkflowStepError, WorkflowTimeoutError, allSettledWithConcurrency, bindResourceDescriptor, buildIterationResponseSchema, compileBusinessOntologyValidationIndex, concurrentPool, createLeadGenStageValidators, defineContract, defineResource, defineResourceOntology, defineResources, defineSingleStepWorkflow, defineTopology, defineTopologyRelationship, defineWorkflowConfig, deriveActions, detectCycle, determineNextStep, diagnosticOutput, errorToString, estimateTokens, getErrorDetails, integrationInput, isBuiltInReadinessProfile, isZodType, logExecutionPath, logStepFailure, logStepStart, logStepSuccess, logWorkflowFailure, logWorkflowStart, logWorkflowSuccess, lookupReadinessProfile, parseTopologyNodeRef, registerReadinessProfile, resolveContractRef, runDiagnostic, splitName, topologyRef, topologyRelationship, truncationCharBudget, validateDeclaredSystemInterfaceReadiness, validateDeploymentSpec, validateEntryPoint, validateRelationships, validateResourceGovernance, validateStepReferences, validateTerminalOutput, validateTerminalSteps };
+export { ActivityEventSchema, BuildPlanSnapshotStepSchema, ContractRefResolutionError, CrmStageKeySchema, CrmStateKeySchema, EmailSchema, ExecutionError, ExecutionError2, LLMResponseParseError, ListBuilderStageKeySchema, ProcessingStageStatusSchema, ProspectingBuildTemplateSchema, RegistryValidationError, ResourceRegistry, StepType, ToolingError, WorkflowCancellationError, WorkflowStalledError, WorkflowStepError, WorkflowStepTimeoutError, WorkflowTimeoutError, allSettledWithConcurrency, bindResourceDescriptor, buildIterationResponseSchema, calculateCost, compileBusinessOntologyValidationIndex, concurrentPool, createLeadGenStageValidators, defineContract, defineResource, defineResourceOntology, defineResources, defineSingleStepWorkflow, defineTopology, defineTopologyRelationship, defineWorkflowConfig, deriveActions, detectCycle, determineNextStep, diagnosticOutput, errorToString, estimateTokens, getErrorDetails, integrationInput, isBuiltInReadinessProfile, isZodType, logExecutionPath, logStepFailure, logStepStart, logStepSuccess, logWorkflowFailure, logWorkflowStart, logWorkflowSuccess, lookupReadinessProfile, parseTopologyNodeRef, registerReadinessProfile, resolveContractRef, runDiagnostic, splitName, topologyRef, topologyRelationship, truncationCharBudget, validateDeclaredSystemInterfaceReadiness, validateDeploymentSpec, validateEntryPoint, validateRelationships, validateResourceGovernance, validateStepReferences, validateTerminalOutput, validateTerminalSteps };