@elevasis/sdk 1.50.0 → 1.52.0

package/dist/{chunk-MGZZ4HL4.js → chunk-T6DTAP2U.js}

@@ -1,8 +1,20 @@
-import { ProcessingStageStatusSchema, ListBuilderStageKeySchema, zodToJsonSchema, LLMResponseParseError, errorToString, getErrorDetails, ExecutionError2, validateEntryPoint, validateTerminalSteps, validateStepReferences, logWorkflowStart, detectCycle, WorkflowStepError, logStepStart, validateTerminalOutput, logStepSuccess, determineNextStep, logStepFailure, logExecutionPath, logWorkflowSuccess, logWorkflowFailure, estimateTokens, validateTokenConfiguration, truncationCharBudget, buildIterationResponseSchema } from './chunk-YJDXRHNP.js';
+import { ProcessingStageStatusSchema, ListBuilderStageKeySchema, zodToJsonSchema, LLMResponseParseError, errorToString, getErrorDetails, ExecutionError2, validateEntryPoint, validateTerminalSteps, validateStepReferences, WorkflowTimeoutError, WorkflowStalledError, WorkflowCancellationError, logWorkflowStart, detectCycle, WorkflowStepError, logStepStart, validateTerminalOutput, logStepSuccess, determineNextStep, logStepFailure, logExecutionPath, logWorkflowSuccess, logWorkflowFailure, estimateTokens, truncationCharBudget, buildIterationResponseSchema } from './chunk-XC57JNMA.js';
 import { workerData, parentPort } from 'worker_threads';
 import { z, ZodError } from 'zod';
 import { createHmac } from 'crypto';
 
+// ../core/src/execution/engine/base/utils.ts
+function abortKindFor(signal) {
+  if (!signal?.aborted) return null;
+  if (signal.reason === "timeout") return "timeout";
+  if (signal.reason === "stalled") return "stalled";
+  return "cancelled";
+}
+
+// ../core/src/platform/constants/timeouts.ts
+var DEFAULT_TOOL_TIMEOUT = 18e5;
+var DEFAULT_EXECUTION_TIMEOUT = 72e5;
+
 // ../core/src/execution/engine/workflow/workflow.ts
 var Workflow = class {
   config;
@@ -26,6 +38,33 @@ var Workflow = class {
     validateTerminalSteps(this.steps, this.config.resourceId);
     validateStepReferences(this.steps);
   }
+  /**
+   * Build the error for an aborted execution, or `null` when the signal has not fired.
+   *
+   * Mirrors `Agent.abortErrorFor`, sharing its `abortKindFor` classification so a cancelled workflow and
+   * a cancelled agent are described the same way, and differing only in the error family -- these carry
+   * `category: 'workflow'`, which is what the `execution_errors` row and the API response report.
+   *
+   * @returns `null` when the signal is not aborted -- callers throw only when this returns non-null.
+   */
+  abortErrorFor(signal, stepId, executionPath) {
+    const kind = abortKindFor(signal);
+    if (!kind) return null;
+    if (kind === "timeout") {
+      return new WorkflowTimeoutError(`Workflow execution exceeded timeout (${DEFAULT_EXECUTION_TIMEOUT}ms)`, {
+        timeout: DEFAULT_EXECUTION_TIMEOUT,
+        stepId,
+        executionPath
+      });
+    }
+    if (kind === "stalled") {
+      return new WorkflowStalledError("Execution stalled: no heartbeat received within threshold", {
+        stepId,
+        executionPath
+      });
+    }
+    return new WorkflowCancellationError("Execution cancelled by user", { stepId, executionPath });
+  }
   /**
    * Execute the workflow with graph-based flow control
    * Context is required for execution tracking, logging, and organization isolation
@@ -40,6 +79,8 @@ var Workflow = class {
       let currentData = validated;
       let currentStepId = this.entryPoint;
       while (currentStepId !== null) {
+        const abortError = this.abortErrorFor(context.signal, currentStepId, executionPath);
+        if (abortError) throw abortError;
         detectCycle(visited, executionPath, currentStepId);
         visited.add(currentStepId);
         executionPath.push(currentStepId);
@@ -585,7 +626,6 @@ function withSynthesizedMessage(nextActions, message) {
   return [{ type: "message", text }, ...nextActions];
 }
 async function callLLMForAgentIteration(adapter, request) {
-  validateTokenConfiguration(request.model, request.constraints.maxOutputTokens);
   const messages = buildAgentMessages(
     request.systemPrompt,
     request.memory,
@@ -648,7 +688,6 @@ async function callLLMForAgentIteration(adapter, request) {
   }
 }
 async function callLLMForAgentCompletion(adapter, request) {
-  validateTokenConfiguration(request.model, request.constraints.maxOutputTokens);
   const messages = buildAgentMessages(
     request.systemPrompt,
     request.memory,
@@ -793,10 +832,23 @@ var ToolingError = class extends ExecutionError2 {
     }
     return "warning";
   }
+  /**
+   * Set by `withRetry` on the error it throws once its own attempts are spent.
+   *
+   * Without it the error type says only what KIND of failure happened, never whether anything has
+   * already been tried, so a retryable classification survives being retried. Nesting one
+   * `withRetry` inside another then multiplies: the integration path wraps `adapter.call` in one
+   * and 54 adapter fetch modules wrap their own request in another, and a persistent provider
+   * failure made 16 requests where the policy says 4.
+   */
+  retryExhausted = false;
   /**
    * Check if error is retryable
    */
   isRetryable() {
+    if (this.retryExhausted) {
+      return false;
+    }
     return [
       "service_unavailable",
       "rate_limit_exceeded",
@@ -827,10 +879,6 @@ function cancelled(message, details) {
   return new ToolingError("cancelled", message, details);
 }
 
-// ../core/src/platform/constants/timeouts.ts
-var DEFAULT_TOOL_TIMEOUT = 18e5;
-var DEFAULT_EXECUTION_TIMEOUT = 72e5;
-
 // ../core/src/execution/engine/agent/memory/truncation.ts
 var CLOSING_BRACKET_RESERVE = 32;
 var DANGLING_KEY_WITH_COLON = /,?\s*"(?:[^"\\]|\\.)*"\s*:\s*$/;
@@ -1172,6 +1220,37 @@ var AgentNoProgressError = class extends AgentError {
   }
 };
 
+// ../core/src/platform/utils/concurrency.ts
+async function allSettledWithConcurrency(items, limit, task) {
+  if (items.length === 0) return [];
+  const bound = Math.max(1, Math.floor(limit));
+  if (bound >= items.length) {
+    return Promise.allSettled(items.map((item, index) => task(item, index)));
+  }
+  const results = new Array(items.length);
+  let cursor = 0;
+  const worker = async () => {
+    while (cursor < items.length) {
+      const index = cursor++;
+      try {
+        results[index] = { status: "fulfilled", value: await task(items[index], index) };
+      } catch (reason) {
+        results[index] = { status: "rejected", reason };
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: bound }, worker));
+  return results;
+}
+
+// ../core/src/platform/constants/limits.ts
+var MAX_SESSION_MEMORY_KEYS = 25;
+var MAX_MEMORY_TOKENS = 32e3;
+var MAX_SESSION_MEMORY_TOKENS = 8e3;
+var MAX_SINGLE_ENTRY_TOKENS = 2e3;
+var MAX_TOOL_RESULT_TOKENS = 4e3;
+var MAX_CONCURRENT_TOOL_CALLS = 8;
+
 // ../core/src/execution/engine/agent/actions/processor.ts
 function normalizeSessionMessages(actions, sessionCapable) {
   if (!sessionCapable) {
@@ -1233,7 +1312,11 @@ async function processActions(iterationContext, response) {
   }
   let shouldComplete = completeRequested && toolCalls.length === 0;
   if (toolCalls.length > 0) {
-    const settled = await Promise.allSettled(toolCalls.map((action) => executeToolCall(iterationContext, action)));
+    const settled = await allSettledWithConcurrency(
+      toolCalls,
+      MAX_CONCURRENT_TOOL_CALLS,
+      (action) => executeToolCall(iterationContext, action)
+    );
     settled.forEach((outcome, index) => {
       if (outcome.status === "rejected") {
         const action = toolCalls[index];
@@ -1401,13 +1484,6 @@ function sanitizeUserInput(input) {
   };
 }
 
-// ../core/src/platform/constants/limits.ts
-var MAX_SESSION_MEMORY_KEYS = 25;
-var MAX_MEMORY_TOKENS = 32e3;
-var MAX_SESSION_MEMORY_TOKENS = 8e3;
-var MAX_SINGLE_ENTRY_TOKENS = 2e3;
-var MAX_TOOL_RESULT_TOKENS = 4e3;
-
 // ../core/src/execution/engine/agent/memory/manager.ts
 var ENVELOPE_FULL_RESULT_WINDOW = 3;
 function parseIfJson(content2) {
@@ -2117,15 +2193,20 @@ var Agent = class {
    * between-iteration check (which never has an error, only the signal) and `wrapAndLogError`
    * (which has both) agree on the same classification.
    *
+   * The reason-reading itself lives in `abortKindFor` so `Workflow.execute` can classify an abort the
+   * same way without borrowing this method's `Agent*` error family -- those carry `category: 'agent'`,
+   * which is written straight through to the `execution_errors` row.
+   *
    * @returns `null` when the signal is not aborted -- callers throw only when this returns non-null.
    */
   abortErrorFor(signal, iteration) {
-    if (!signal?.aborted) return null;
-    if (signal.reason === "timeout") {
+    const kind = abortKindFor(signal);
+    if (!kind) return null;
+    if (kind === "timeout") {
       const timeout = this.config.constraints?.timeout ?? DEFAULT_EXECUTION_TIMEOUT;
       return new AgentTimeoutError(`Agent execution exceeded timeout (${timeout}ms)`, { timeout, iteration });
     }
-    if (signal.reason === "stalled") {
+    if (kind === "stalled") {
       return new AgentStalledError("Execution stalled: no heartbeat received within threshold", { iteration });
     }
     return new AgentCancellationError("Execution cancelled by user", { iteration });
@@ -2549,7 +2630,7 @@ function handleToolResult(msg) {
     const code = msg.code ?? "unknown_error";
     pending.reject(new PlatformToolError(msg.error, code, RETRYABLE_CODES.has(code)));
   } else {
-    pending.resolve(msg.result);
+    pending.resolve(msg.result, msg.usage);
   }
 }
 function handleCredentialResult(msg) {
@@ -2566,6 +2647,45 @@ function handleCredentialResult(msg) {
     });
   }
 }
+async function sendToolCall(options) {
+  if (!parentPort) {
+    throw new PlatformToolError("platform.call() can only be used inside a worker thread", "service_unavailable", false);
+  }
+  const id = `tc_${++callCounter}_${Date.now()}`;
+  const message = {
+    type: "tool-call",
+    id,
+    tool: options.tool,
+    method: options.method,
+    params: options.params ?? {},
+    credential: options.credential
+  };
+  return new Promise((resolve, reject) => {
+    const timeoutMs = 18e5;
+    const timeoutLabel = "1800s";
+    const timer = setTimeout(() => {
+      pendingCalls.delete(id);
+      reject(
+        new PlatformToolError(
+          `Platform tool call timed out after ${timeoutLabel}: ${options.tool}.${options.method}`,
+          "timeout_error",
+          true
+        )
+      );
+    }, timeoutMs);
+    pendingCalls.set(id, {
+      resolve: (value, usage) => {
+        clearTimeout(timer);
+        resolve({ result: value, usage });
+      },
+      reject: (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    });
+    parentPort.postMessage(message);
+  });
+}
 var platform = {
   /**
    * Call a platform tool from the worker thread.
@@ -2578,47 +2698,24 @@ var platform = {
    * @throws PlatformToolError on failure (with code and retryable fields)
    */
   async call(options) {
-    if (!parentPort) {
-      throw new PlatformToolError(
-        "platform.call() can only be used inside a worker thread",
-        "service_unavailable",
-        false
-      );
-    }
-    const id = `tc_${++callCounter}_${Date.now()}`;
-    const message = {
-      type: "tool-call",
-      id,
-      tool: options.tool,
-      method: options.method,
-      params: options.params ?? {},
-      credential: options.credential
-    };
-    return new Promise((resolve, reject) => {
-      const timeoutMs = 18e5;
-      const timeoutLabel = "1800s";
-      const timer = setTimeout(() => {
-        pendingCalls.delete(id);
-        reject(
-          new PlatformToolError(
-            `Platform tool call timed out after ${timeoutLabel}: ${options.tool}.${options.method}`,
-            "timeout_error",
-            true
-          )
-        );
-      }, timeoutMs);
-      pendingCalls.set(id, {
-        resolve: (value) => {
-          clearTimeout(timer);
-          resolve(value);
-        },
-        reject: (error) => {
-          clearTimeout(timer);
-          reject(error);
-        }
-      });
-      parentPort.postMessage(message);
-    });
+    const { result } = await sendToolCall(options);
+    return result;
+  },
+  /**
+   * Call a platform tool and also surface any `usage` (token/cost) metadata the parent attached
+   * to the response -- e.g. the `llm` tool's real provider usage from the API-side
+   * `dispatchToolCall` in `tool-dispatcher.ts`. Bare `result` is unchanged from `call()`; `usage` is `undefined` whenever the
+   * parent's response didn't carry one, exactly like today's `call()` behavior for that result.
+   *
+   * @param options.tool - Tool name (e.g., 'llm')
+   * @param options.method - Method name (e.g., 'generate')
+   * @param options.params - Method parameters
+   * @param options.credential - Credential name (required for integration tools)
+   * @returns Promise resolving to `{ result, usage }`
+   * @throws PlatformToolError on failure (with code and retryable fields)
+   */
+  async callWithUsage(options) {
+    return sendToolCall(options);
   },
   /**
    * Request raw credential access from the platform.
@@ -2673,7 +2770,7 @@ var PostMessageLLMAdapter = class {
     this.model = model;
   }
   async generate(request) {
-    const result = await platform.call({
+    const { result, usage } = await platform.callWithUsage({
       tool: "llm",
       method: "generate",
       params: {
@@ -2689,7 +2786,17 @@ var PostMessageLLMAdapter = class {
         maxOutputTokens: request.maxOutputTokens
       }
     });
-    return { output: result };
+    return {
+      output: result,
+      ...usage && {
+        usage: {
+          inputTokens: usage.inputTokens,
+          outputTokens: usage.outputTokens,
+          totalTokens: usage.inputTokens + usage.outputTokens
+        }
+      },
+      ...usage?.cost !== void 0 && { cost: usage.cost }
+    };
   }
 };
 function createPostMessageAdapterFactory() {
@@ -4349,11 +4456,27 @@ function startWorker(org) {
             throw new Error("Agent did not produce memory snapshot");
           }
           const durationMs = Date.now() - startTime;
-          console.log(`[SDK-WORKER] Agent '${resourceId}' completed (${durationMs}ms)`);
+          const stopReason = agentInstance.getStopReason();
+          const budgetExhausted = stopReason === "budget_exhausted";
+          if (budgetExhausted) {
+            console.warn(`[SDK-WORKER] Agent '${resourceId}' exhausted its iteration budget (${durationMs}ms)`);
+          } else {
+            console.log(`[SDK-WORKER] Agent '${resourceId}' completed (${durationMs}ms)`);
+          }
           parentPort.postMessage({
             type: "result",
-            status: "completed",
+            status: budgetExhausted ? "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"
+            } : {},
             output,
+            stopReason,
+            // Whether the agent emitted an assistant message this turn. `Agent` has tracked this for
+            // the `agent-turn-silent` detector, which logged to a sink nothing reads; carrying it lets
+            // a silent turn be seen where the turn is recorded.
+            hasSpoken: agentInstance.hasSpoken(),
             memorySnapshot,
             logs,
             metrics: { durationMs }
@@ -4367,6 +4490,10 @@ function startWorker(org) {
             type: "result",
             status: "failed",
             ...serializedError,
+            // Carried on the throwing path too: a turn that failed after the agent had already
+            // stopped for its own reason is a different diagnosis from one that failed mid-iteration,
+            // and `stopReason` is the only thing that separates them.
+            ...agentInstance ? { stopReason: agentInstance.getStopReason(), hasSpoken: agentInstance.hasSpoken() } : {},
             ...memorySnapshot ? { memorySnapshot } : {},
             logs,
             metrics: { durationMs }

package/dist/{chunk-YJDXRHNP.js → chunk-XC57JNMA.js}

@@ -4610,6 +4610,41 @@ var WorkflowValidationError = class extends ExecutionError2 {
     super(message, context);
   }
 };
+var WorkflowTimeoutError = class extends ExecutionError2 {
+  type = "workflow_timeout_error";
+  severity = "critical";
+  category = "workflow";
+  constructor(message, context) {
+    super(message, context);
+  }
+  /** The ceiling was reached, so a retry has no budget to run in. */
+  isRetryable() {
+    return false;
+  }
+};
+var WorkflowStalledError = class extends ExecutionError2 {
+  type = "workflow_stalled_error";
+  severity = "critical";
+  category = "workflow";
+  constructor(message, context) {
+    super(message, context);
+  }
+  isRetryable() {
+    return false;
+  }
+};
+var WorkflowCancellationError = class extends ExecutionError2 {
+  type = "workflow_cancellation_error";
+  severity = "warning";
+  category = "workflow";
+  constructor(message, context) {
+    super(message, context);
+  }
+  /** The user asked for this. Retrying would override an explicit instruction. */
+  isRetryable() {
+    return false;
+  }
+};
 
 // ../core/src/execution/engine/workflow/utils.ts
 function validateEntryPoint(steps, entryPoint) {
@@ -5377,11 +5412,6 @@ function validateAgentGrammar(orgName, agentId, agent, mode) {
 function validateAgentCheapAssertions(orgName, agentId, agent, mode) {
   const issues = [];
   const config = agent.config;
-  if (config.sessionCapable && config.securityLevel === "none") {
-    issues.push(
-      `securityLevel: 'none' on a sessionCapable agent -- a session agent takes untrusted user input and must run with prompt-injection defenses ('standard' or 'hardened').`
-    );
-  }
   if (!isStubDefinition(agent) && !config.systemPrompt.trim()) {
     issues.push(`systemPrompt is empty -- an agent with no behavioural instructions cannot be deployed.`);
   }
@@ -5660,6 +5690,48 @@ function validateHumanCheckpoints(orgName, humanCheckpoints, allInternalIds, val
   });
 }
 
+// ../core/src/execution/engine/base/redaction.ts
+function normalizeKey(key) {
+  return key.toLowerCase().replace(/[_\-.\s]/g, "");
+}
+var SECRET_PATTERNS = [
+  "apikey",
+  "secret",
+  "password",
+  "passphrase",
+  "token",
+  "credential",
+  "privatekey",
+  "accesskey",
+  "authorization",
+  "bearer"
+];
+var SECRET_PLURAL_EXCEPTIONS = /* @__PURE__ */ new Set([
+  "refreshtokens",
+  "accesstokens",
+  "apitokens",
+  "authtokens",
+  "bearertokens",
+  "sessiontokens",
+  "bypasstokens",
+  "validtokens"
+]);
+function isTokenCountKey(normalized) {
+  if (SECRET_PLURAL_EXCEPTIONS.has(normalized)) return false;
+  if (normalized.endsWith("tokens")) return true;
+  return ["tokenbudget", "tokenlimit", "tokencount", "tokenusage"].some((k) => normalized.includes(k));
+}
+function isSecretKey(key) {
+  const normalized = normalizeKey(key);
+  if (isTokenCountKey(normalized)) return false;
+  return SECRET_PATTERNS.some((pattern) => normalized.includes(pattern));
+}
+function redactSecretValue(value) {
+  if (typeof value !== "string") return "[REDACTED]";
+  if (value.length <= 7) return "[REDACTED]";
+  return value.substring(0, 7) + "...";
+}
+
 // ../core/src/execution/engine/base/serialization.ts
 function serializeDefinition(definition, options) {
   const opts = {
@@ -5697,7 +5769,7 @@ function serializeObject(obj, ctx) {
   for (const [key, val] of Object.entries(obj)) {
     if (typeof val === "function") continue;
     if (ctx.redactSecrets && isSecretKey(key)) {
-      result[key] = redactSecret(val);
+      result[key] = redactSecretValue(val);
       continue;
     }
     if (key === "steps" && isWorkflowStepsRecord(val)) {
@@ -5783,18 +5855,6 @@ function isToolObject(value) {
 function isNextConfigObject(value) {
   return value && typeof value === "object" && "type" in value && (value.type === StepType2.LINEAR || value.type === StepType2.CONDITIONAL);
 }
-function isSecretKey(key) {
-  const lower = key.toLowerCase();
-  const whitelist = ["maxtokens", "memorytokens", "inputtokens", "outputtokens"];
-  if (whitelist.some((w) => lower.includes(w))) return false;
-  const patterns = ["apikey", "secret", "password", "token", "credential"];
-  return patterns.some((p) => lower.includes(p));
-}
-function redactSecret(value) {
-  if (typeof value !== "string") return "[REDACTED]";
-  if (value.length <= 7) return "[REDACTED]";
-  return value.substring(0, 7) + "...";
-}
 
 // ../core/src/platform/registry/serialization.ts
 function summarizeSystem(system) {
@@ -7898,4 +7958,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, WorkflowStepError, bindResourceDescriptor, buildIterationResponseSchema, compileBusinessOntologyValidationIndex, concurrentPool, createLeadGenStageValidators, defineContract, defineResource, defineResourceOntology, defineResources, defineStep, defineTopology, defineTopologyRelationship, defineWorkflow, 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, validateTokenConfiguration, zodToJsonSchema };
+export { ActivityEventSchema, BuildPlanSnapshotStepSchema, ContractRefResolutionError, CrmStageKeySchema, CrmStateKeySchema, EmailSchema, ExecutionError, ExecutionError2, LLMResponseParseError, ListBuilderStageKeySchema, ProcessingStageStatusSchema, ProspectingBuildTemplateSchema, RegistryValidationError, ResourceRegistry, StepType, ToolingError, WorkflowCancellationError, WorkflowStalledError, WorkflowStepError, WorkflowTimeoutError, bindResourceDescriptor, buildIterationResponseSchema, compileBusinessOntologyValidationIndex, concurrentPool, createLeadGenStageValidators, defineContract, defineResource, defineResourceOntology, defineResources, defineStep, defineTopology, defineTopologyRelationship, defineWorkflow, 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, zodToJsonSchema };