@elevasis/sdk 1.44.3 → 1.45.0

package/dist/node/index.d.ts

@@ -263,6 +263,31 @@ interface AgentScopedLogger {
     lifecycle(lifecycle: AgentLifecycle, stage: 'failed', data: AgentLifecycleFailedData): void;
     reasoning(output: string, iteration: number, startTime: number, endTime: number, duration: number): void;
     action(actionType: string, message: string, iteration: number, startTime: number, endTime: number, duration: number): void;
+    /**
+     * Time a unit of work and emit the single `action` event it produces.
+     *
+     * Captures `Date.now()` immediately before and after `work()`, then emits the same event
+     * `action()` would -- collapsing the repeated `startTime = Date.now(); ...work...; endTime =
+     * Date.now(); action(actionType, message, iteration, startTime, endTime, endTime - startTime)`
+     * boilerplate found at memory-write and tool-result call sites into a single call.
+     *
+     * `actionType` may be a function of the work's result for the rare call site where the emitted
+     * type itself depends on the outcome (e.g. "deleted" vs "delete of a missing key") -- most
+     * callers just pass a fixed string.
+     *
+     * **Throw behavior:** if `work` throws synchronously or its promise rejects, the error propagates
+     * to the caller UNCHANGED and NO `action` event is emitted -- there is no completed unit of work
+     * to describe, so this deliberately does not swallow the error or log a synthetic failure action.
+     * A call site that needs an error-path log keeps calling `action()` manually from its own
+     * `catch` block.
+     *
+     * @param actionType - Action type string, or a function deriving it from the result
+     * @param iteration - Current iteration number
+     * @param work - The unit of work to time (sync or async)
+     * @param message - Builds the human-readable message from the work's result
+     * @returns The value returned by `work`
+     */
+    timed<T>(actionType: string | ((result: T) => string), iteration: number, work: () => Promise<T> | T, message: (result: T) => string): Promise<T>;
     toolCall(toolName: string, iteration: number, startTime: number, endTime: number, duration: number, success: boolean, error?: string, input?: unknown, output?: unknown): void;
 }
 
@@ -279,7 +304,19 @@ declare const ResourceGovernanceStatusSchema: z.ZodEnum<{
     deprecated: "deprecated";
     archived: "archived";
 }>;
-declare const WorkflowResourceEntrySchema$1: z.ZodObject<{
+declare const ResourceOntologyBindingSchema: z.ZodObject<{
+    actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    primaryAction: z.ZodOptional<z.ZodString>;
+    reads: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    usesCatalogs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    contract: z.ZodOptional<z.ZodObject<{
+        input: z.ZodOptional<z.ZodString>;
+        output: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const WorkflowResourceEntrySchema: z.ZodObject<{
     id: z.ZodString;
     order: z.ZodDefault<z.ZodNumber>;
     systemPath: z.ZodString;
@@ -330,7 +367,7 @@ declare const WorkflowResourceEntrySchema$1: z.ZodObject<{
         }>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
-declare const AgentResourceEntrySchema$1: z.ZodObject<{
+declare const AgentResourceEntrySchema: z.ZodObject<{
     id: z.ZodString;
     order: z.ZodDefault<z.ZodNumber>;
     systemPath: z.ZodString;
@@ -412,6 +449,46 @@ declare const AgentResourceEntrySchema$1: z.ZodObject<{
         }>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
+declare const IntegrationResourceEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    order: z.ZodDefault<z.ZodNumber>;
+    systemPath: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    ownerRoleId: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        active: "active";
+        deprecated: "deprecated";
+        archived: "archived";
+    }>;
+    ontology: z.ZodOptional<z.ZodObject<{
+        actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        primaryAction: z.ZodOptional<z.ZodString>;
+        reads: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        writes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        usesCatalogs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        emits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        contract: z.ZodOptional<z.ZodObject<{
+            input: z.ZodOptional<z.ZodString>;
+            output: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    codeRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        role: z.ZodEnum<{
+            entrypoint: "entrypoint";
+            handler: "handler";
+            schema: "schema";
+            test: "test";
+            docs: "docs";
+            config: "config";
+        }>;
+        symbol: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    kind: z.ZodLiteral<"integration">;
+    provider: z.ZodString;
+}, z.core.$strip>;
 declare const ResourceEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     id: z.ZodString;
     order: z.ZodDefault<z.ZodNumber>;
@@ -631,8 +708,8 @@ declare const ResourceEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>]>;
 }, z.core.$strip>], "kind">;
 type ResourceGovernanceStatus = z.infer<typeof ResourceGovernanceStatusSchema>;
-type WorkflowResourceEntry = z.infer<typeof WorkflowResourceEntrySchema$1>;
-type AgentResourceEntry = z.infer<typeof AgentResourceEntrySchema$1>;
+type WorkflowResourceEntry = z.infer<typeof WorkflowResourceEntrySchema>;
+type AgentResourceEntry = z.infer<typeof AgentResourceEntrySchema>;
 type ResourceEntry = z.infer<typeof ResourceEntrySchema>;
 
 /**
@@ -753,13 +830,6 @@ interface MemoryStatus {
     storedHistoryPercent: number;
     historyBudget: number;
 }
-/**
- * Memory constraints (optional limits)
- */
-interface MemoryConstraints {
-    maxSessionMemoryKeys?: number;
-    maxMemoryTokens?: number;
-}
 
 /**
  * Types for the schema compiler. `compile.ts` walks a `JsonSchema` once, driven entirely by a
@@ -1156,14 +1226,13 @@ declare class MemoryManager {
     private memory;
     private constraints;
     private logger?;
-    private cachedSnapshot?;
     /**
      * Rolling correction for `estimateTokens`'s bias, learned from real provider usage.
      * `undefined` until the first `recordActualUsage` call -- the cold-start state, where
      * `estimate()` returns the raw `estimateTokens` output unscaled. See `recordActualUsage`.
      */
     private tokenCorrectionFactor?;
-    constructor(memory: AgentMemory, constraints?: MemoryConstraints, logger?: AgentScopedLogger | undefined);
+    constructor(memory: AgentMemory, constraints?: AgentConstraints, logger?: AgentScopedLogger | undefined);
     /**
      * Record how far `estimateTokens` was from reality on a real provider call, and roll it into a
      * correction applied to every estimate this instance makes from here on -- `getStatus`'s three
@@ -1258,17 +1327,14 @@ declare class MemoryManager {
      */
     getStatus(currentTurn?: number): MemoryStatus;
     /**
-     * Create memory snapshot for persistence
-     * Caches snapshot internally for later retrieval
+     * Create a memory snapshot for persistence.
+     *
+     * Stateless: every call returns a fresh `structuredClone` of the current memory, so the caller
+     * owns caching if it needs to hold onto the result across calls (see `Agent.memorySnapshot`).
+     *
      * @returns Deep copy of current memory state
      */
-    toSnapshot(): AgentMemory;
-    /**
-     * Get cached memory snapshot
-     * Returns snapshot created by toSnapshot()
-     * @returns Cached snapshot (undefined if toSnapshot() not called yet)
-     */
-    getSnapshot(): AgentMemory | undefined;
+    snapshot(): AgentMemory;
     /**
      * Build the framework framing and the untrusted data envelope for an LLM call.
      *
@@ -1571,8 +1637,7 @@ declare const SystemApiInterfaceSchema: z.ZodObject<{
     resourceIds: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
     readinessContract: z.ZodOptional<z.ZodObject<{
         requiredObjects: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        requiredCatalogs: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        requiredKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        requiredCatalogs: z.ZodArray<z.ZodString>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 type JsonPrimitive = string | number | boolean | null;
@@ -1678,7 +1743,7 @@ declare const LinkSchema: z.ZodObject<{
 }, z.core.$strip>;
 type Link = z.infer<typeof LinkSchema>;
 
-declare const OrganizationModelSchema$1: z.ZodObject<{
+declare const OrganizationModelSchema: z.ZodObject<{
     version: z.ZodDefault<z.ZodLiteral<1>>;
     snapshotHash: z.ZodOptional<z.ZodString>;
     domainMetadata: z.ZodPipe<z.ZodDefault<z.ZodObject<{
@@ -2740,7 +2805,11 @@ declare const OrganizationModelSchema$1: z.ZodObject<{
     }, z.core.$strip>>>>;
 }, z.core.$strip>;
 
-type OrganizationModel$1 = z.infer<typeof OrganizationModelSchema$1>;
+type OrganizationModel = z.infer<typeof OrganizationModelSchema>;
+type OrganizationModelResourceOntologyBinding = z.infer<typeof ResourceOntologyBindingSchema>;
+type OrganizationModelWorkflowResourceEntry = z.infer<typeof WorkflowResourceEntrySchema>;
+type OrganizationModelAgentResourceEntry = z.infer<typeof AgentResourceEntrySchema>;
+type OrganizationModelIntegrationResourceEntry = z.infer<typeof IntegrationResourceEntrySchema>;
 
 /**
  * AIUsageCollector
@@ -3036,10 +3105,15 @@ interface ResourceMetricsConfig {
  * - API process: provides createLLMAdapter (real SDKs + process.env API keys)
  * - SDK worker: provides PostMessageLLMAdapter (proxies via platform.call)
  *
- * Uses `any` for optional params so both the real createLLMAdapter (with typed
- * AIUsageCollector/AICallContext) and the worker proxy (which ignores them) satisfy the type.
- */
-type LLMAdapterFactory = (config: ModelConfig, ...args: any[]) => LLMAdapter;
+ * Signature mirrors `createLLMAdapter`'s real parameter list. `context` is narrowed to the two
+ * shapes an agent ever actually builds (`processReasoning` passes `AgentReasoningContext`,
+ * `Agent.callLLMForOutput` passes `AgentCompletionContext`) rather than the full `AICallContext`
+ * union `createLLMAdapter` accepts -- a narrower optional param here is still assignable to the
+ * wider one there. `createPostMessageAdapterFactory()`'s worker proxy ignores every param past
+ * `config`; a shorter-arity function remains assignable to a longer optional-param function type,
+ * so it still satisfies this type unchanged.
+ */
+type LLMAdapterFactory = (config: ModelConfig, aiUsageCollector?: AIUsageCollector, callType?: BaseAICall['callType'], context?: AgentReasoningContext | AgentCompletionContext, organizationId?: string) => LLMAdapter;
 type AgentKind = 'orchestrator' | 'specialist' | 'utility' | 'platform';
 interface AgentConfig extends ResourceDefinition {
     type: 'agent';
@@ -3669,7 +3743,7 @@ interface DeploymentSpec {
     /** Deployment version (semver) */
     version: string;
     /** Optional full Organization Model snapshot used for OM-code validation and deployment persistence */
-    organizationModel?: OrganizationModel$1;
+    organizationModel?: OrganizationModel;
     /** Workflow definitions */
     workflows?: WorkflowDefinition[];
     /** Agent definitions */
@@ -3719,72 +3793,6 @@ interface ResolvedKnowledgeLayout {
 }
 declare function runKnowledgeCodegen(layout: ResolvedKnowledgeLayout): Promise<void>;
 
-declare const ResourceOntologyBindingSchema = z
-  .object({
-    actions: z.array(OntologyIdSchema).optional(),
-    primaryAction: OntologyIdSchema.optional(),
-    reads: z.array(OntologyIdSchema).optional(),
-    writes: z.array(OntologyIdSchema).optional(),
-    usesCatalogs: z.array(OntologyIdSchema).optional(),
-    emits: z.array(OntologyIdSchema).optional(),
-    /**
-     * Optional typed contract binding for this resource's workflow I/O.
-     * Each ref is a `package/subpath#ExportName` string that resolves to a
-     * Zod schema in the tenant-owned organization model package.
-     *
-     * Absence of this field preserves all existing behavior — it is additive + optional.
-     * Tier-1 validation (schema.ts): ref-string shape only (browser-safe, no imports).
-     * Tier-2 validation (om:verify): intra-package typed-map resolution asserts ZodType.
-     */
-    contract: z
-      .object({
-        input: ContractRefSchema.optional(),
-        output: ContractRefSchema.optional()
-      })
-      .optional()
-  })
-  .superRefine((binding, ctx) => {
-    if (binding.primaryAction === undefined) return
-    if (binding.actions?.includes(binding.primaryAction)) return
-
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      path: ['primaryAction'],
-      message: 'Resource ontology primaryAction must be included in actions'
-    })
-  })
-
-declare const WorkflowResourceEntrySchema = ResourceEntryBaseSchema.extend({
-  kind: z.literal('workflow'),
-  emits: z.array(EventEmissionDescriptorSchema).optional()
-})
-
-declare const AgentResourceEntrySchema = ResourceEntryBaseSchema.extend({
-  kind: z.literal('agent'),
-  /** Mirrors code-side AgentConfig.kind. */
-  agentKind: AgentKindSchema,
-  /** Role this agent embodies, if any. */
-  actsAsRoleId: ModelIdSchema.meta({ ref: 'role' }).optional(),
-  /** Mirrors AgentConfig.sessionCapable. */
-  sessionCapable: z.boolean(),
-  /** Broad/composite callable entry points orchestrated by this agent. */
-  invocations: z.array(ActionInvocationSchema).default([]),
-  emits: z.array(EventEmissionDescriptorSchema).optional()
-})
-
-declare const IntegrationResourceEntrySchema = ResourceEntryBaseSchema.extend({
-  kind: z.literal('integration'),
-  provider: z.string().trim().min(1).max(100)
-})
-
-declare const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine(refineOrganizationModel)
-
-type OrganizationModel = z.infer<typeof OrganizationModelSchema>
-type OrganizationModelResourceOntologyBinding = z.infer<typeof ResourceOntologyBindingSchema>
-type OrganizationModelWorkflowResourceEntry = z.infer<typeof WorkflowResourceEntrySchema>
-type OrganizationModelAgentResourceEntry = z.infer<typeof AgentResourceEntrySchema>
-type OrganizationModelIntegrationResourceEntry = z.infer<typeof IntegrationResourceEntrySchema>
-
 type ResourceOntologyBindingResolver = (resourceId: string) => OrganizationModelResourceOntologyBinding | undefined;
 type WorkflowResourceDescriptorResolver = (resourceId: string) => OrganizationModelWorkflowResourceEntry;
 type AgentResourceDescriptorResolver = (resourceId: string) => OrganizationModelAgentResourceEntry;

package/dist/test-utils/index.d.ts

@@ -226,6 +226,31 @@ interface AgentScopedLogger {
     lifecycle(lifecycle: AgentLifecycle, stage: 'failed', data: AgentLifecycleFailedData): void;
     reasoning(output: string, iteration: number, startTime: number, endTime: number, duration: number): void;
     action(actionType: string, message: string, iteration: number, startTime: number, endTime: number, duration: number): void;
+    /**
+     * Time a unit of work and emit the single `action` event it produces.
+     *
+     * Captures `Date.now()` immediately before and after `work()`, then emits the same event
+     * `action()` would -- collapsing the repeated `startTime = Date.now(); ...work...; endTime =
+     * Date.now(); action(actionType, message, iteration, startTime, endTime, endTime - startTime)`
+     * boilerplate found at memory-write and tool-result call sites into a single call.
+     *
+     * `actionType` may be a function of the work's result for the rare call site where the emitted
+     * type itself depends on the outcome (e.g. "deleted" vs "delete of a missing key") -- most
+     * callers just pass a fixed string.
+     *
+     * **Throw behavior:** if `work` throws synchronously or its promise rejects, the error propagates
+     * to the caller UNCHANGED and NO `action` event is emitted -- there is no completed unit of work
+     * to describe, so this deliberately does not swallow the error or log a synthetic failure action.
+     * A call site that needs an error-path log keeps calling `action()` manually from its own
+     * `catch` block.
+     *
+     * @param actionType - Action type string, or a function deriving it from the result
+     * @param iteration - Current iteration number
+     * @param work - The unit of work to time (sync or async)
+     * @param message - Builds the human-readable message from the work's result
+     * @returns The value returned by `work`
+     */
+    timed<T>(actionType: string | ((result: T) => string), iteration: number, work: () => Promise<T> | T, message: (result: T) => string): Promise<T>;
     toolCall(toolName: string, iteration: number, startTime: number, endTime: number, duration: number, success: boolean, error?: string, input?: unknown, output?: unknown): void;
 }
 
@@ -716,13 +741,6 @@ interface MemoryStatus {
     storedHistoryPercent: number;
     historyBudget: number;
 }
-/**
- * Memory constraints (optional limits)
- */
-interface MemoryConstraints {
-    maxSessionMemoryKeys?: number;
-    maxMemoryTokens?: number;
-}
 
 /**
  * Types for the schema compiler. `compile.ts` walks a `JsonSchema` once, driven entirely by a
@@ -1119,14 +1137,13 @@ declare class MemoryManager {
     private memory;
     private constraints;
     private logger?;
-    private cachedSnapshot?;
     /**
      * Rolling correction for `estimateTokens`'s bias, learned from real provider usage.
      * `undefined` until the first `recordActualUsage` call -- the cold-start state, where
      * `estimate()` returns the raw `estimateTokens` output unscaled. See `recordActualUsage`.
      */
     private tokenCorrectionFactor?;
-    constructor(memory: AgentMemory, constraints?: MemoryConstraints, logger?: AgentScopedLogger | undefined);
+    constructor(memory: AgentMemory, constraints?: AgentConstraints, logger?: AgentScopedLogger | undefined);
     /**
      * Record how far `estimateTokens` was from reality on a real provider call, and roll it into a
      * correction applied to every estimate this instance makes from here on -- `getStatus`'s three
@@ -1221,17 +1238,14 @@ declare class MemoryManager {
      */
     getStatus(currentTurn?: number): MemoryStatus;
     /**
-     * Create memory snapshot for persistence
-     * Caches snapshot internally for later retrieval
+     * Create a memory snapshot for persistence.
+     *
+     * Stateless: every call returns a fresh `structuredClone` of the current memory, so the caller
+     * owns caching if it needs to hold onto the result across calls (see `Agent.memorySnapshot`).
+     *
      * @returns Deep copy of current memory state
      */
-    toSnapshot(): AgentMemory;
-    /**
-     * Get cached memory snapshot
-     * Returns snapshot created by toSnapshot()
-     * @returns Cached snapshot (undefined if toSnapshot() not called yet)
-     */
-    getSnapshot(): AgentMemory | undefined;
+    snapshot(): AgentMemory;
     /**
      * Build the framework framing and the untrusted data envelope for an LLM call.
      *
@@ -4535,10 +4549,6 @@ type Database = {
                 Args: Record<PropertyKey, never>;
                 Returns: string;
             };
-            detect_stalled_executions: {
-                Args: Record<PropertyKey, never>;
-                Returns: undefined;
-            };
             execute_session_turn: {
                 Args: {
                     p_session_id: string;
@@ -6140,8 +6150,7 @@ declare const SystemApiInterfaceSchema: z.ZodObject<{
     resourceIds: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
     readinessContract: z.ZodOptional<z.ZodObject<{
         requiredObjects: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        requiredCatalogs: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        requiredKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        requiredCatalogs: z.ZodArray<z.ZodString>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 type JsonPrimitive = string | number | boolean | null;
@@ -10609,10 +10618,15 @@ interface ResourceMetricsConfig {
  * - API process: provides createLLMAdapter (real SDKs + process.env API keys)
  * - SDK worker: provides PostMessageLLMAdapter (proxies via platform.call)
  *
- * Uses `any` for optional params so both the real createLLMAdapter (with typed
- * AIUsageCollector/AICallContext) and the worker proxy (which ignores them) satisfy the type.
- */
-type LLMAdapterFactory = (config: ModelConfig, ...args: any[]) => LLMAdapter;
+ * Signature mirrors `createLLMAdapter`'s real parameter list. `context` is narrowed to the two
+ * shapes an agent ever actually builds (`processReasoning` passes `AgentReasoningContext`,
+ * `Agent.callLLMForOutput` passes `AgentCompletionContext`) rather than the full `AICallContext`
+ * union `createLLMAdapter` accepts -- a narrower optional param here is still assignable to the
+ * wider one there. `createPostMessageAdapterFactory()`'s worker proxy ignores every param past
+ * `config`; a shorter-arity function remains assignable to a longer optional-param function type,
+ * so it still satisfies this type unchanged.
+ */
+type LLMAdapterFactory = (config: ModelConfig, aiUsageCollector?: AIUsageCollector, callType?: BaseAICall['callType'], context?: AgentReasoningContext | AgentCompletionContext, organizationId?: string) => LLMAdapter;
 type AgentKind = 'orchestrator' | 'specialist' | 'utility' | 'platform';
 interface AgentConfig extends ResourceDefinition {
     type: 'agent';