@ekairos/events 1.22.39-beta.development.0 → 1.22.40-beta.development.0

package/dist/context.step-stream.js

@@ -1,4 +1,5 @@
 import { isContextStreamChunkType, } from "./context.contract.js";
+import { assertValidContextPartChunkIdentity } from "./context.part-identity.js";
 export const CONTEXT_STEP_STREAM_VERSION = 1;
 function assertObject(value, label) {
     if (!value || typeof value !== "object") {
@@ -15,43 +16,84 @@ function assertNumber(value, label) {
         throw new Error(`Invalid ${label}: expected number.`);
     }
 }
+function assertPositiveInteger(value, label) {
+    assertNumber(value, label);
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new Error(`Invalid ${label}: expected positive integer.`);
+    }
+}
+function assertIsoDateString(value, label) {
+    assertString(value, label);
+    if (Number.isNaN(Date.parse(value))) {
+        throw new Error(`Invalid ${label}: expected ISO date string.`);
+    }
+}
 function assertOptionalString(value, label) {
     if (typeof value === "undefined")
         return;
     assertString(value, label);
 }
 export function createContextStepStreamChunk(params) {
-    return {
+    const chunk = {
         version: CONTEXT_STEP_STREAM_VERSION,
         at: params.at ?? new Date().toISOString(),
         sequence: params.sequence,
         chunkType: params.chunkType,
+        partId: params.partId,
+        providerPartId: params.providerPartId,
+        partType: params.partType,
+        partSlot: params.partSlot,
         provider: params.provider,
         providerChunkType: params.providerChunkType,
         actionRef: params.actionRef,
         data: params.data,
         raw: params.raw,
     };
+    validateContextStepStreamChunk(chunk, {
+        stepId: params.stepId,
+        label: "context step stream chunk",
+    });
+    return chunk;
 }
-export function parseContextStepStreamChunk(value) {
-    const parsed = typeof value === "string" ? JSON.parse(value) : value;
-    assertObject(parsed, "context step stream chunk");
-    assertNumber(parsed.version, "context step stream chunk.version");
-    if (parsed.version !== CONTEXT_STEP_STREAM_VERSION) {
-        throw new Error(`Unsupported context step stream chunk version: ${String(parsed.version)}`);
+export function validateContextStepStreamChunk(value, options = {}) {
+    const label = options.label ?? "context step stream chunk";
+    assertObject(value, label);
+    assertNumber(value.version, `${label}.version`);
+    if (value.version !== CONTEXT_STEP_STREAM_VERSION) {
+        throw new Error(`Unsupported ${label}.version: ${String(value.version)}`);
     }
-    assertString(parsed.at, "context step stream chunk.at");
-    assertNumber(parsed.sequence, "context step stream chunk.sequence");
-    assertString(parsed.chunkType, "context step stream chunk.chunkType");
-    if (!isContextStreamChunkType(parsed.chunkType)) {
-        throw new Error(`Invalid context step stream chunk.chunkType: ${String(parsed.chunkType)}`);
+    assertIsoDateString(value.at, `${label}.at`);
+    assertPositiveInteger(value.sequence, `${label}.sequence`);
+    assertString(value.chunkType, `${label}.chunkType`);
+    if (!isContextStreamChunkType(value.chunkType)) {
+        throw new Error(`Invalid ${label}.chunkType: ${String(value.chunkType)}`);
     }
-    assertOptionalString(parsed.provider, "context step stream chunk.provider");
-    assertOptionalString(parsed.providerChunkType, "context step stream chunk.providerChunkType");
-    assertOptionalString(parsed.actionRef, "context step stream chunk.actionRef");
+    assertOptionalString(value.partId, `${label}.partId`);
+    assertOptionalString(value.providerPartId, `${label}.providerPartId`);
+    assertOptionalString(value.partType, `${label}.partType`);
+    assertOptionalString(value.partSlot, `${label}.partSlot`);
+    assertOptionalString(value.provider, `${label}.provider`);
+    assertOptionalString(value.providerChunkType, `${label}.providerChunkType`);
+    assertOptionalString(value.actionRef, `${label}.actionRef`);
+    assertValidContextPartChunkIdentity({
+        label,
+        stepId: options.stepId,
+        chunkType: value.chunkType,
+        partId: value.partId,
+        provider: value.provider,
+        providerPartId: value.providerPartId,
+        partType: value.partType,
+        partSlot: value.partSlot,
+        actionRef: value.actionRef,
+    });
+}
+export function parseContextStepStreamChunk(value, options = {}) {
+    const parsed = typeof value === "string" ? JSON.parse(value) : value;
+    validateContextStepStreamChunk(parsed, options);
     return parsed;
 }
-export function encodeContextStepStreamChunk(chunk) {
+export function encodeContextStepStreamChunk(chunk, options = {}) {
+    validateContextStepStreamChunk(chunk, options);
     return `${JSON.stringify(chunk)}\n`;
 }
 export function contextStreamByteLength(value) {

package/dist/context.stream.d.ts

@@ -129,6 +129,10 @@ export type ChunkEmittedEvent = ContextStreamEventBase & {
     stepId?: string;
     itemId?: string;
     partKey?: string;
+    partId?: string;
+    providerPartId?: string;
+    partType?: string;
+    partSlot?: string;
     actionRef?: string;
     provider?: string;
     providerChunkType?: string;

package/dist/context.stream.js

@@ -1,4 +1,5 @@
 import { isContextStreamChunkType } from "./context.contract.js";
+import { assertValidContextPartChunkIdentity } from "./context.part-identity.js";
 function assertObject(value, label) {
     if (!value || typeof value !== "object") {
         throw new Error(`Invalid ${label}: expected object.`);
@@ -14,6 +15,12 @@ function assertNumber(value, label) {
         throw new Error(`Invalid ${label}: expected number.`);
     }
 }
+function assertPositiveInteger(value, label) {
+    assertNumber(value, label);
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new Error(`Invalid ${label}: expected positive integer.`);
+    }
+}
 function assertOptionalString(value, label) {
     if (value !== undefined) {
         assertString(value, label);
@@ -121,10 +128,25 @@ export function parseContextStreamEvent(value) {
             assertOptionalString(value.stepId, `${type}.stepId`);
             assertOptionalString(value.itemId, `${type}.itemId`);
             assertOptionalString(value.partKey, `${type}.partKey`);
+            assertOptionalString(value.partId, `${type}.partId`);
+            assertOptionalString(value.providerPartId, `${type}.providerPartId`);
+            assertOptionalString(value.partType, `${type}.partType`);
+            assertOptionalString(value.partSlot, `${type}.partSlot`);
             assertOptionalString(value.actionRef, `${type}.actionRef`);
             assertOptionalString(value.provider, `${type}.provider`);
             assertOptionalString(value.providerChunkType, `${type}.providerChunkType`);
-            assertOptionalNumber(value.sequence, `${type}.sequence`);
+            assertPositiveInteger(value.sequence, `${type}.sequence`);
+            assertValidContextPartChunkIdentity({
+                label: type,
+                chunkType: value.chunkType,
+                stepId: typeof value.stepId === "string" ? value.stepId : undefined,
+                partId: typeof value.partId === "string" ? value.partId : undefined,
+                provider: typeof value.provider === "string" ? value.provider : undefined,
+                providerPartId: typeof value.providerPartId === "string" ? value.providerPartId : undefined,
+                partType: typeof value.partType === "string" ? value.partType : undefined,
+                partSlot: typeof value.partSlot === "string" ? value.partSlot : undefined,
+                actionRef: typeof value.actionRef === "string" ? value.actionRef : undefined,
+            });
             return value;
         }
         default:

package/dist/context.toolcalls.d.ts

@@ -1,13 +1,12 @@
 /**
  * ## context.toolcalls.ts
  *
- * This module isolates the **tool-call plumbing** used by `context.engine.ts`.
+ * This module isolates the **action-call plumbing** used by `context.engine.ts`.
  *
- * In our runtime, tool calls are represented as **event parts** produced by the AI SDK.
+ * In our runtime, model tool calls are normalized into semantic `action` event parts.
  * The engine needs to:
- * - extract a normalized list of tool calls from `event.content.parts`, and
- * - merge tool execution outcomes back into those parts (so the persisted event reflects
- *   `output-available` / `output-error`, etc.).
+ * - extract a normalized list of action requests from `event.content.parts`, and
+ * - merge action execution outcomes back into those parts.
  *
  * Keeping this logic here helps `context.engine.ts` read like orchestration, and keeps
  * these transformations testable and reusable.
@@ -19,28 +18,17 @@ export type ToolCall = {
     args: any;
 };
 /**
- * Extracts tool calls from an event's `parts` array.
+ * Extracts action requests from an event's `parts` array.
  *
- * Expected part shape (loosely):
- * - `type`: string like `"tool-<toolName>"`
- * - `toolCallId`: string
- * - `input`: any (tool args)
- *
- * We intentionally treat the input as `any` because the part schema is produced by the AI SDK.
+ * Also accepts raw AI SDK tool UI parts before persistence normalization.
  */
 export declare function extractToolCallsFromParts(parts: any[] | undefined | null): ToolCall[];
 /**
- * Applies a tool execution outcome to the matching tool part.
+ * Applies an action execution outcome to the matching action part.
  *
  * This does not mutate `parts` — it returns a new array.
  *
- * We match the tool part by:
- * - `type === "tool-<toolName>"` and
- * - `toolCallId` equality
- *
- * Then we set:
- * - on success: `{ state: "output-available", output: <result> }`
- * - on failure: `{ state: "output-error", errorText: <message> }`
+ * We match by action name and action call id.
  */
 export declare function applyToolExecutionResultToParts(parts: any[], toolCall: Pick<ToolCall, "toolCallId" | "toolName">, execution: {
     success: boolean;

package/dist/context.toolcalls.js

@@ -1,38 +1,30 @@
 /**
  * ## context.toolcalls.ts
  *
- * This module isolates the **tool-call plumbing** used by `context.engine.ts`.
+ * This module isolates the **action-call plumbing** used by `context.engine.ts`.
  *
- * In our runtime, tool calls are represented as **event parts** produced by the AI SDK.
+ * In our runtime, model tool calls are normalized into semantic `action` event parts.
  * The engine needs to:
- * - extract a normalized list of tool calls from `event.content.parts`, and
- * - merge tool execution outcomes back into those parts (so the persisted event reflects
- *   `output-available` / `output-error`, etc.).
+ * - extract a normalized list of action requests from `event.content.parts`, and
+ * - merge action execution outcomes back into those parts.
  *
  * Keeping this logic here helps `context.engine.ts` read like orchestration, and keeps
  * these transformations testable and reusable.
  */
-import { isContextPartEnvelope, normalizePartsForPersistence, normalizeToolResultContentToBlocks, } from "./context.parts.js";
+import { isContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
 /**
- * Extracts tool calls from an event's `parts` array.
+ * Extracts action requests from an event's `parts` array.
  *
- * Expected part shape (loosely):
- * - `type`: string like `"tool-<toolName>"`
- * - `toolCallId`: string
- * - `input`: any (tool args)
- *
- * We intentionally treat the input as `any` because the part schema is produced by the AI SDK.
+ * Also accepts raw AI SDK tool UI parts before persistence normalization.
  */
 export function extractToolCallsFromParts(parts) {
     const safeParts = parts ?? [];
     return safeParts.reduce((acc, p) => {
-        if (isContextPartEnvelope(p) && p.type === "tool-call") {
-            const firstContent = Array.isArray(p.content) ? p.content[0] : undefined;
-            const args = firstContent && firstContent.type === "json" ? firstContent.value : p.content;
+        if (isContextPartEnvelope(p) && p.type === "action" && p.content.status === "started") {
             acc.push({
-                toolCallId: p.toolCallId,
-                toolName: p.toolName,
-                args,
+                toolCallId: p.content.actionCallId,
+                toolName: p.content.actionName,
+                args: p.content.input,
             });
             return acc;
         }
@@ -44,56 +36,70 @@ export function extractToolCallsFromParts(parts) {
     }, []);
 }
 /**
- * Applies a tool execution outcome to the matching tool part.
+ * Applies an action execution outcome to the matching action part.
  *
  * This does not mutate `parts` — it returns a new array.
  *
- * We match the tool part by:
- * - `type === "tool-<toolName>"` and
- * - `toolCallId` equality
- *
- * Then we set:
- * - on success: `{ state: "output-available", output: <result> }`
- * - on failure: `{ state: "output-error", errorText: <message> }`
+ * We match by action name and action call id.
  */
 export function applyToolExecutionResultToParts(parts, toolCall, execution) {
     const normalized = normalizePartsForPersistence(parts);
     const next = [];
     let insertedResult = false;
-    const resultContent = execution.success
-        ? normalizeToolResultContentToBlocks(execution.result)
-        : [
-            {
-                type: "text",
-                text: String(execution.message || "Error"),
-            },
-        ];
     for (const part of normalized) {
         next.push(part);
-        if (part.type !== "tool-call") {
+        if (part.type !== "action" || part.content.status !== "started") {
             continue;
         }
-        if (part.toolCallId !== toolCall.toolCallId ||
-            part.toolName !== toolCall.toolName) {
+        if (part.content.actionCallId !== toolCall.toolCallId ||
+            part.content.actionName !== toolCall.toolName) {
             continue;
         }
-        next.push({
-            type: "tool-result",
-            toolCallId: toolCall.toolCallId,
-            toolName: toolCall.toolName,
-            state: execution.success ? "output-available" : "output-error",
-            content: resultContent,
-        });
+        next.push(execution.success
+            ? {
+                type: "action",
+                content: {
+                    status: "completed",
+                    actionCallId: toolCall.toolCallId,
+                    actionName: toolCall.toolName,
+                    output: execution.result,
+                },
+            }
+            : {
+                type: "action",
+                content: {
+                    status: "failed",
+                    actionCallId: toolCall.toolCallId,
+                    actionName: toolCall.toolName,
+                    error: {
+                        message: String(execution.message || "Error"),
+                    },
+                },
+            });
         insertedResult = true;
     }
     if (!insertedResult) {
-        next.push({
-            type: "tool-result",
-            toolCallId: toolCall.toolCallId,
-            toolName: toolCall.toolName,
-            state: execution.success ? "output-available" : "output-error",
-            content: resultContent,
-        });
+        next.push(execution.success
+            ? {
+                type: "action",
+                content: {
+                    status: "completed",
+                    actionCallId: toolCall.toolCallId,
+                    actionName: toolCall.toolName,
+                    output: execution.result,
+                },
+            }
+            : {
+                type: "action",
+                content: {
+                    status: "failed",
+                    actionCallId: toolCall.toolCallId,
+                    actionName: toolCall.toolName,
+                    error: {
+                        message: String(execution.message || "Error"),
+                    },
+                },
+            });
     }
     return next;
 }
@@ -109,9 +115,9 @@ export function applyToolExecutionResultToParts(parts, toolCall, execution) {
  */
 export function didToolExecute(event, toolName) {
     const parts = (event.content.parts ?? []).flatMap((part) => isContextPartEnvelope(part) ? [part] : normalizePartsForPersistence([part]));
-    return parts.some((p) => (p.type === "tool-result" &&
-        p.toolName === toolName &&
-        (p.state === "output-available" || p.state === "output-error")) ||
+    return parts.some((p) => (p.type === "action" &&
+        p.content.actionName === toolName &&
+        (p.content.status === "completed" || p.content.status === "failed")) ||
         (p.type === `tool-${toolName}` &&
             (p.state === "output-available" || p.state === "output-error")));
 }

package/dist/index.d.ts

@@ -1,18 +1,22 @@
-export { context, createContext, createAiSdkReactor, createScriptedReactor, type CreateAiSdkReactorOptions, type CreateScriptedReactorOptions, type ScriptedReactorStep, type ContextConfig, type ContextInstance, type ContextOptions, type ContextStreamOptions, type ContextReactor, type ContextReactorParams, type ContextReactionResult, type ContextActionRequest, type ContextReactionLLM, ContextEngine, type RegistrableContextBuilder, type ContextReactParams, type ContextReactResult, type ContextWorkflowRun, type ContextDurableWorkflowPayload, type ContextDurableWorkflowFunction, type ContextModelInit, type ContextTool, type ContextToolExecuteContext, runContextReactionDirect, } from "./context.js";
+export { context, createContext, createAiSdkReactor, createScriptedReactor, type CreateAiSdkReactorOptions, type CreateScriptedReactorOptions, type ScriptedReactorStep, type ContextConfig, type ContextInstance, type ContextOptions, type ContextStreamOptions, type ContextReactor, type ContextReactorParams, type ContextReactionResult, type ContextActionRequest, type ContextReactionLLM, ContextEngine, defineAction, action, type RegistrableContextBuilder, type ContextReactParams, type ContextDirectReactParams, type ContextDurableReactParams, type ContextReactResult, type ContextReactBase, type ContextReactFinalResult, type ContextDirectRun, type ContextReactRun, type ContextWorkflowRun, type ContextDurableWorkflowPayload, type ContextDurableWorkflowFunction, type ContextModelInit, type ContextTool, type ContextAction, type ContextActionBase, type ContextActionExecuteParams, type AnyContextAction, type ContextActionDefinition, type DefineContextActionDefinition, type DefineContextActionExecute, type LegacyContextActionDefinition, type LegacyContextActionExecute, type ContextActionExecute, type ContextActionInput, type ContextActionOutput, type ContextProviderDefinedAction, type ContextActionSchema, type ContextToolExecuteContext, runContextReactionDirect, } from "./context.js";
 export type { ContextStore, ContextIdentifier, StoredContext, ContextItem, ContextExecution, } from "./context.store.js";
 export type { WireDate, ContextMirrorContext, ContextMirrorExecution, ContextMirrorWrite, ContextMirrorRequest, } from "./mirror.js";
 export { registerContext, getContext, getContextFactory, hasContext, listContexts, type ContextKey, } from "./context.registry.js";
 export { eventsDomain } from "./schema.js";
 export { didToolExecute, extractToolCallsFromParts } from "./context.toolcalls.js";
-export { contextPartSchema, contextPartEnvelopeSchema, contextPartContentSchema, isContextPartEnvelope, parseContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
-export type { ContextPart, ContextPartEnvelope, ContextPartContent, } from "./context.parts.js";
+export { actionsToActionSpecs, actionSpecToAiSdkTool, type SerializableActionSpec, type SerializableFunctionActionSpec, type SerializableProviderDefinedActionSpec, } from "./tools-to-model-tools.js";
+export { reactorMetadataSchema, contextPartSchema, contextPartEnvelopeSchema, contextPartContentSchema, contextMessagePartSchema, contextReasoningPartSchema, contextSourcePartSchema, contextActionPartSchema, contextEnginePartSchema, createContextPartSchema, parseContextPart, isContextPartEnvelope, parseContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
+export type { ReactorMetadata, ContextEnginePart, ContextActionPart, ContextActionStartedPart, ContextActionCompletedPart, ContextActionFailedPart, ContextPartActionMap, ContextPart, ContextPartEnvelope, ContextPartContent, ContextInlineContent, } from "./context.parts.js";
 export { INPUT_ITEM_TYPE, INPUT_TEXT_ITEM_TYPE, OUTPUT_ITEM_TYPE, WEB_CHANNEL, AGENT_CHANNEL, EMAIL_CHANNEL, createUserItemFromUIMessages, createAssistantItemFromUIMessages, convertToUIMessage, convertItemToModelMessages, convertItemsToModelMessages, convertModelMessageToItem, isContextOutputPart, normalizeContextOutputPart, type ResponseMessage, type ContextOutputPart, type ContextOutputContentPart, } from "./context.events.js";
 export { CONTEXT_STATUSES, EXECUTION_STATUSES, STEP_STATUSES, STEP_KINDS, ITEM_STATUSES, ITEM_TYPES, CHANNELS, TRACE_EVENT_KINDS, CONTEXT_STREAM_CHUNK_TYPES, STREAM_LIFECYCLE_CHUNK_TYPES, STREAM_TEXT_CHUNK_TYPES, STREAM_REASONING_CHUNK_TYPES, STREAM_ACTION_CHUNK_TYPES, STREAM_SOURCE_CHUNK_TYPES, STREAM_METADATA_CHUNK_TYPES, STREAM_ERROR_CHUNK_TYPES, CONTEXT_TRANSITIONS, EXECUTION_TRANSITIONS, STEP_TRANSITIONS, ITEM_TRANSITIONS, canContextTransition, canExecutionTransition, canStepTransition, canItemTransition, assertContextTransition, assertExecutionTransition, assertStepTransition, assertItemTransition, isContextStreamChunkType, assertContextPartKey, } from "./context.contract.js";
 export type { Transition, ContextStatus, ExecutionStatus, StepStatus, StepKind, ItemStatus, ItemType, Channel, TraceEventKind, ContextStreamChunkType, ContextTransition, ExecutionTransition, StepTransition, ItemTransition, } from "./context.contract.js";
 export { DEFAULT_CODEX_TOOL_NAME, DEFAULT_CODEX_MODEL, codexToolInputSchema, buildDefaultCodexNarrative, didCodexToolExecute, createCodexContextBuilder, type CodexContextRuntimeMode, type CodexContextReasoningLevel, type CodexContextRuntime, type CodexContextEnv, type CodexToolInput, type CodexToolOutput, type CodexExecuteArgs, type CodexContextBuilderConfig, type CodexContextBuilder, } from "./codex.js";
 export { useContext, type ContextSnapshot, type ContextStreamChunk, type UseContextOptions, } from "./react.js";
 export { parseContextStreamEvent, assertContextStreamTransitions, validateContextStreamTimeline, } from "./context.stream.js";
-export { CONTEXT_STEP_STREAM_VERSION, createContextStepStreamChunk, parseContextStepStreamChunk, encodeContextStepStreamChunk, } from "./context.step-stream.js";
+export { CONTEXT_STEP_STREAM_VERSION, createContextStepStreamChunk, validateContextStepStreamChunk, parseContextStepStreamChunk, encodeContextStepStreamChunk, } from "./context.step-stream.js";
+export type { ContextStepStreamChunkValidationOptions, } from "./context.step-stream.js";
+export { CONTEXT_PART_ID_NAMESPACE, CONTEXT_PART_UUID_RE, CONTEXT_STREAM_PART_TYPES, assertValidContextPartChunkIdentity, resolveContextPartChunkDescriptor, resolveContextPartChunkIdentity, resolveContextPartId, resolveContextStreamPartSlot, resolveContextStreamPartType, uuidV5, } from "./context.part-identity.js";
+export type { ContextPartChunkDescriptor, ContextPartChunkIdentity, ContextPartChunkIdentityInput, ContextPartChunkValidationInput, ContextStreamPartSlot, ContextStreamPartType, } from "./context.part-identity.js";
 export type { ContextStreamEvent, ContextCreatedEvent, ContextResolvedEvent, ContextStatusChangedEvent, ContextContentUpdatedEvent, ExecutionCreatedEvent, ExecutionCompletedEvent, ExecutionFailedEvent, ItemCreatedEvent, ItemUpdatedEvent, ItemPendingEvent, ItemCompletedEvent, StepCreatedEvent, StepUpdatedEvent, StepCompletedEvent, StepFailedEvent, PartCreatedEvent, PartUpdatedEvent, ChunkEmittedEvent, } from "./context.stream.js";
 export type { ContextStepStreamChunk } from "./context.step-stream.js";
 export type { ContextSkillPackage, ContextSkillPackageFile } from "./context.skill.js";

package/dist/index.js

@@ -1,11 +1,13 @@
-export { context, createContext, createAiSdkReactor, createScriptedReactor, ContextEngine, runContextReactionDirect, } from "./context.js";
+export { context, createContext, createAiSdkReactor, createScriptedReactor, ContextEngine, defineAction, action, runContextReactionDirect, } from "./context.js";
 export { registerContext, getContext, getContextFactory, hasContext, listContexts, } from "./context.registry.js";
 export { eventsDomain } from "./schema.js";
 export { didToolExecute, extractToolCallsFromParts } from "./context.toolcalls.js";
-export { contextPartSchema, contextPartEnvelopeSchema, contextPartContentSchema, isContextPartEnvelope, parseContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
+export { actionsToActionSpecs, actionSpecToAiSdkTool, } from "./tools-to-model-tools.js";
+export { reactorMetadataSchema, contextPartSchema, contextPartEnvelopeSchema, contextPartContentSchema, contextMessagePartSchema, contextReasoningPartSchema, contextSourcePartSchema, contextActionPartSchema, contextEnginePartSchema, createContextPartSchema, parseContextPart, isContextPartEnvelope, parseContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
 export { INPUT_ITEM_TYPE, INPUT_TEXT_ITEM_TYPE, OUTPUT_ITEM_TYPE, WEB_CHANNEL, AGENT_CHANNEL, EMAIL_CHANNEL, createUserItemFromUIMessages, createAssistantItemFromUIMessages, convertToUIMessage, convertItemToModelMessages, convertItemsToModelMessages, convertModelMessageToItem, isContextOutputPart, normalizeContextOutputPart, } from "./context.events.js";
 export { CONTEXT_STATUSES, EXECUTION_STATUSES, STEP_STATUSES, STEP_KINDS, ITEM_STATUSES, ITEM_TYPES, CHANNELS, TRACE_EVENT_KINDS, CONTEXT_STREAM_CHUNK_TYPES, STREAM_LIFECYCLE_CHUNK_TYPES, STREAM_TEXT_CHUNK_TYPES, STREAM_REASONING_CHUNK_TYPES, STREAM_ACTION_CHUNK_TYPES, STREAM_SOURCE_CHUNK_TYPES, STREAM_METADATA_CHUNK_TYPES, STREAM_ERROR_CHUNK_TYPES, CONTEXT_TRANSITIONS, EXECUTION_TRANSITIONS, STEP_TRANSITIONS, ITEM_TRANSITIONS, canContextTransition, canExecutionTransition, canStepTransition, canItemTransition, assertContextTransition, assertExecutionTransition, assertStepTransition, assertItemTransition, isContextStreamChunkType, assertContextPartKey, } from "./context.contract.js";
 export { DEFAULT_CODEX_TOOL_NAME, DEFAULT_CODEX_MODEL, codexToolInputSchema, buildDefaultCodexNarrative, didCodexToolExecute, createCodexContextBuilder, } from "./codex.js";
 export { useContext, } from "./react.js";
 export { parseContextStreamEvent, assertContextStreamTransitions, validateContextStreamTimeline, } from "./context.stream.js";
-export { CONTEXT_STEP_STREAM_VERSION, createContextStepStreamChunk, parseContextStepStreamChunk, encodeContextStepStreamChunk, } from "./context.step-stream.js";
+export { CONTEXT_STEP_STREAM_VERSION, createContextStepStreamChunk, validateContextStepStreamChunk, parseContextStepStreamChunk, encodeContextStepStreamChunk, } from "./context.step-stream.js";
+export { CONTEXT_PART_ID_NAMESPACE, CONTEXT_PART_UUID_RE, CONTEXT_STREAM_PART_TYPES, assertValidContextPartChunkIdentity, resolveContextPartChunkDescriptor, resolveContextPartChunkIdentity, resolveContextPartId, resolveContextStreamPartSlot, resolveContextStreamPartType, uuidV5, } from "./context.part-identity.js";

package/dist/reactors/ai-sdk.chunk-map.js

@@ -1,3 +1,4 @@
+import { resolveContextPartChunkIdentity } from "../context.part-identity.js";
 const REDACT_KEY = /token|authorization|cookie|secret|api[_-]?key|password/i;
 function asRecord(value) {
     if (!value || typeof value !== "object")
@@ -119,10 +120,32 @@ function buildNormalizedData(chunk) {
     }
     return toJsonSafe(normalized) ?? {};
 }
+function readProviderPartId(chunk, chunkType) {
+    if (chunkType.startsWith("chunk.action_")) {
+        return readString(chunk, "toolCallId") ?? readString(chunk, "id");
+    }
+    if (chunkType.startsWith("chunk.text_") || chunkType.startsWith("chunk.reasoning_")) {
+        return readString(chunk, "id");
+    }
+    if (chunkType.startsWith("chunk.source_")) {
+        return readString(chunk, "sourceId");
+    }
+    if (chunkType === "chunk.file") {
+        return readString(chunk, "id") ?? readString(chunk, "url");
+    }
+    return undefined;
+}
 export function mapAiSdkChunkToContextEvent(params) {
     const chunk = asRecord(params.chunk);
     const providerChunkType = readString(chunk, "type") ?? "unknown";
     const chunkType = mapAiSdkChunkType(providerChunkType);
+    const providerPartId = readProviderPartId(chunk, chunkType);
+    const identity = resolveContextPartChunkIdentity({
+        stepId: params.stepId,
+        provider: params.provider ?? "ai-sdk",
+        providerPartId,
+        chunkType,
+    });
     const actionRef = readString(chunk, "toolCallId") ??
         readString(chunk, "id");
     return {
@@ -133,6 +156,10 @@ export function mapAiSdkChunkToContextEvent(params) {
         executionId: params.executionId,
         stepId: params.stepId,
         itemId: params.itemId,
+        partId: identity?.partId,
+        providerPartId: identity?.providerPartId,
+        partType: identity?.partType,
+        partSlot: identity?.partSlot,
         actionRef: chunkType.startsWith("chunk.action_") ? actionRef : undefined,
         provider: params.provider,
         providerChunkType,

package/dist/reactors/ai-sdk.reactor.d.ts

@@ -1,12 +1,13 @@
 import type { ContextEnvironment } from "../context.config.js";
-import type { ContextRuntime } from "../context.runtime.js";
+import type { DomainSchemaResult } from "@ekairos/domain";
+import type { ContextRuntime, ContextRuntimeHandleForDomain } from "../context.runtime.js";
 import type { ContextModelInit } from "../context.engine.js";
 import type { ContextIdentifier, StoredContext, ContextItem } from "../context.store.js";
+import { eventsDomain } from "../schema.js";
 import type { ContextReactor } from "./types.js";
-export type CreateAiSdkReactorOptions<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, Config = unknown> = {
+export type CreateAiSdkReactorOptions<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>, Config = unknown> = {
     resolveConfig?: (params: {
-        runtime: ContextRuntime<Env>;
-        env: Env;
+        runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
         context: StoredContext<Context>;
         contextIdentifier: ContextIdentifier;
         triggerEvent: ContextItem;
@@ -18,20 +19,18 @@ export type CreateAiSdkReactorOptions<Context = unknown, Env extends ContextEnvi
         iteration: number;
     }) => Promise<Config> | Config;
     selectModel?: (params: {
-        runtime: ContextRuntime<Env>;
-        env: Env;
+        runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
         context: StoredContext<Context>;
         triggerEvent: ContextItem;
         baseModel: ContextModelInit;
         config: Config;
     }) => Promise<ContextModelInit> | ContextModelInit;
     selectMaxModelSteps?: (params: {
-        runtime: ContextRuntime<Env>;
-        env: Env;
+        runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
         context: StoredContext<Context>;
         triggerEvent: ContextItem;
         baseMaxModelSteps: number;
         config: Config;
     }) => Promise<number> | number;
 };
-export declare function createAiSdkReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, Config = unknown>(options?: CreateAiSdkReactorOptions<Context, Env, Config>): ContextReactor<Context, Env>;
+export declare function createAiSdkReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>, Config = unknown>(options?: CreateAiSdkReactorOptions<Context, Env, RequiredDomain, Runtime, Config>): ContextReactor<Context, Env, RequiredDomain, Runtime>;

package/dist/reactors/ai-sdk.reactor.js

@@ -1,11 +1,11 @@
 import { executeAiSdkReaction } from "./ai-sdk.step.js";
+import { actionsToActionSpecs } from "../tools-to-model-tools.js";
 export function createAiSdkReactor(options) {
     return async (params) => {
         let config;
         if (options?.resolveConfig) {
             config = await options.resolveConfig({
                 runtime: params.runtime,
-                env: params.env,
                 context: params.context,
                 contextIdentifier: params.contextIdentifier,
                 triggerEvent: params.triggerEvent,
@@ -20,7 +20,6 @@ export function createAiSdkReactor(options) {
         const model = options?.selectModel && config !== undefined
             ? await options.selectModel({
                 runtime: params.runtime,
-                env: params.env,
                 context: params.context,
                 triggerEvent: params.triggerEvent,
                 baseModel: params.model,
@@ -30,7 +29,6 @@ export function createAiSdkReactor(options) {
         const maxSteps = options?.selectMaxModelSteps && config !== undefined
             ? await options.selectMaxModelSteps({
                 runtime: params.runtime,
-                env: params.env,
                 context: params.context,
                 triggerEvent: params.triggerEvent,
                 baseMaxModelSteps: params.maxModelSteps,
@@ -39,12 +37,11 @@ export function createAiSdkReactor(options) {
             : params.maxModelSteps;
         const result = await executeAiSdkReaction({
             runtime: params.runtime,
-            env: params.env,
             contextIdentifier: params.contextIdentifier,
             events: params.events,
             model,
             system: params.systemPrompt,
-            tools: params.actionSpecs,
+            tools: actionsToActionSpecs(params.actions),
             eventId: params.eventId,
             iteration: params.iteration,
             maxSteps,

package/dist/reactors/ai-sdk.step.d.ts

@@ -13,9 +13,8 @@ import { type SerializableActionSpec } from "../tools-to-model-tools.js";
  * - map provider chunks to the Context stream contract
  * - emit UI chunks and persist step stream chunks
  */
-export declare function executeAiSdkReaction(params: {
-    runtime: import("../context.runtime.js").ContextRuntime<ContextEnvironment>;
-    env: ContextEnvironment;
+export declare function executeAiSdkReaction<Env extends ContextEnvironment = ContextEnvironment>(params: {
+    runtime: import("../context.runtime.js").ContextRuntimeServiceHandle;
     contextIdentifier: ContextIdentifier;
     events?: ContextItem[];
     model: ContextModelInit;

package/dist/reactors/ai-sdk.step.js

@@ -13,7 +13,7 @@ async function readWorkflowMetadata() {
         return null;
     }
 }
-async function resolveWorkflowRunId(env, executionId) {
+async function resolveWorkflowRunId(runtime, executionId) {
     let runId = "";
     const meta = await readWorkflowMetadata();
     if (meta && meta.workflowRunId !== undefined && meta.workflowRunId !== null) {
@@ -21,9 +21,7 @@ async function resolveWorkflowRunId(env, executionId) {
     }
     if (!runId && executionId) {
         try {
-            const { getContextRuntime } = await import("../runtime.js");
-            const runtime = await getContextRuntime(env);
-            const db = runtime?.db;
+            const db = await runtime.db();
             if (db) {
                 const q = await db.query({
                     event_executions: {
@@ -135,7 +133,7 @@ export async function executeAiSdkReaction(params) {
         rejectFinish = reject;
     });
     const modelId = typeof params.model === "string" ? params.model : "";
-    const mappedProvider = modelId.includes("/") ? modelId.split("/")[0] : undefined;
+    const mappedProvider = modelId.includes("/") ? modelId.split("/")[0] || "ai-sdk" : "ai-sdk";
     const contextStepStreamWriter = params.contextStepStream?.getWriter();
     try {
         const uiStream = result
@@ -180,6 +178,11 @@ export async function executeAiSdkReaction(params) {
                         at: mapped.at,
                         sequence: mapped.sequence,
                         chunkType: mapped.chunkType,
+                        stepId: params.stepId,
+                        partId: mapped.partId,
+                        providerPartId: mapped.providerPartId,
+                        partType: mapped.partType,
+                        partSlot: mapped.partSlot,
                         provider: mapped.provider,
                         providerChunkType: mapped.providerChunkType,
                         actionRef: mapped.actionRef,
@@ -294,10 +297,10 @@ export async function executeAiSdkReaction(params) {
             rawProviderMetadata: providerMetadataJson,
         };
     try {
-        const runId = await resolveWorkflowRunId(params.env, params.executionId);
+        const runId = await resolveWorkflowRunId(params.runtime, params.executionId);
         if (runId && llm) {
             await writeContextTraceEvents({
-                env: params.env,
+                runtime: params.runtime,
                 events: [
                     {
                         workflowRunId: runId,