@ekairos/events 1.22.82-beta.development.0 → 1.22.84-beta.development.0

package/dist/context.stream.d.ts

@@ -23,6 +23,14 @@ export type ContextContentUpdatedEvent = ContextStreamEventBase & {
     type: "context.content_updated";
     contextId: string;
 };
+export type ContextDefinitionUpdatedEvent = ContextStreamEventBase & {
+    type: "context.definition_updated";
+    contextId: string;
+};
+export type ContextResourcesUpdatedEvent = ContextStreamEventBase & {
+    type: "context.resources_updated";
+    contextId: string;
+};
 export type ExecutionCreatedEvent = ContextStreamEventBase & {
     type: "execution.created";
     executionId: string;
@@ -138,7 +146,7 @@ export type ChunkEmittedEvent = ContextStreamEventBase & {
     data?: unknown;
     raw?: unknown;
 };
-export type ContextLifecycleEvent = ContextCreatedEvent | ContextResolvedEvent | ContextStatusChangedEvent | ContextContentUpdatedEvent;
+export type ContextLifecycleEvent = ContextCreatedEvent | ContextResolvedEvent | ContextStatusChangedEvent | ContextContentUpdatedEvent | ContextDefinitionUpdatedEvent | ContextResourcesUpdatedEvent;
 export type ExecutionEvent = ExecutionCreatedEvent | ExecutionCompletedEvent | ExecutionFailedEvent;
 export type ItemEvent = ItemCreatedEvent | ItemUpdatedEvent | ItemPendingEvent | ItemCompletedEvent;
 export type StepEvent = StepCreatedEvent | StepUpdatedEvent | StepCompletedEvent | StepFailedEvent;

package/dist/context.stream.js

@@ -48,6 +48,14 @@ export function parseContextStreamEvent(value) {
             assertString(value.contextId, `${type}.contextId`);
             return value;
         }
+        case "context.definition_updated": {
+            assertString(value.contextId, `${type}.contextId`);
+            return value;
+        }
+        case "context.resources_updated": {
+            assertString(value.contextId, `${type}.contextId`);
+            return value;
+        }
         case "execution.created":
         case "execution.completed":
         case "execution.failed": {

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-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 { context, createContext, createAiSdkReactor, createScriptedReactor, type CreateAiSdkReactorOptions, type CreateScriptedReactorOptions, type ScriptedReactorStep, type ContextConfig, type ContextResourcesParams, 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, ContextResource, ContextResourceBase, ContextFileResource, ContextLinkResource, ContextRepositoryResource, ContextDatasetResource, ContextExternalResource, StoredContextResource, 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 { didActionExecute, extractActionCallsFromParts, type ContextActionCall, } from "./context.action-calls.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";
@@ -16,6 +16,6 @@ export { CONTEXT_STEP_STREAM_VERSION, createContextStepStreamChunk, validateCont
 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 { ContextStreamEvent, ContextCreatedEvent, ContextResolvedEvent, ContextStatusChangedEvent, ContextContentUpdatedEvent, ContextDefinitionUpdatedEvent, ContextResourcesUpdatedEvent, 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,7 +1,7 @@
 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 { didActionExecute, extractActionCallsFromParts, } from "./context.action-calls.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";

package/dist/react.step-stream.js

@@ -71,6 +71,72 @@ function parseActionInputText(value) {
         return value;
     }
 }
+function firstString(...values) {
+    for (const value of values) {
+        const text = asString(value).trim();
+        if (text)
+            return text;
+    }
+    return "";
+}
+function firstDefined(...values) {
+    for (const value of values) {
+        if (value !== undefined)
+            return value;
+    }
+    return undefined;
+}
+function parseMaybeJsonValue(value) {
+    if (typeof value !== "string")
+        return value;
+    return parseActionInputText(value);
+}
+function providerContentItemsToValue(value) {
+    if (!Array.isArray(value)) {
+        const record = asRecord(value);
+        if (Array.isArray(record.contentItems))
+            return providerContentItemsToValue(record.contentItems);
+        if (record.output !== undefined)
+            return parseMaybeJsonValue(record.output);
+        return parseMaybeJsonValue(value);
+    }
+    const blocks = value
+        .map((entry) => {
+        const record = asRecord(entry);
+        if (record.type === "inputText" ||
+            record.type === "outputText" ||
+            record.type === "text" ||
+            record.type === "input_text") {
+            const text = asString(record.text || record.input_text);
+            return text ? parseMaybeJsonValue(text) : undefined;
+        }
+        return Object.keys(record).length > 0 ? record : undefined;
+    })
+        .filter((entry) => entry !== undefined);
+    if (blocks.length === 0)
+        return undefined;
+    if (blocks.length === 1)
+        return blocks[0];
+    return { type: "content", value: blocks };
+}
+function readProviderActionDetails(params) {
+    const result = asRecord(params.rawParams.result);
+    const rawError = asRecord(params.rawParams.error);
+    const resultError = asRecord(result.error);
+    const rawItemError = asRecord(params.rawItem.error);
+    const actionCallId = firstString(params.data.actionCallId, params.raw.actionCallId, params.rawParams.actionCallId, params.data.toolCallId, params.rawParams.callId, params.rawParams.toolCallId, params.rawParams.itemId, params.rawParams.id, params.rawItem.callId, params.rawItem.toolCallId, params.rawItem.itemId, params.rawItem.id, params.raw.toolCallId, params.raw.id);
+    const actionName = firstString(params.data.actionName, params.raw.actionName, params.rawParams.actionName, params.rawParams.tool, params.rawParams.toolName, params.rawParams.name, params.rawItem.actionName, params.rawItem.tool, params.rawItem.toolName, params.rawItem.name, params.raw.toolName, params.raw.name);
+    const input = parseMaybeJsonValue(firstDefined(params.data.input, params.data.arguments, params.raw.input, params.raw.args, params.raw.arguments, params.rawParams.arguments, params.rawParams.input, params.rawParams.args, params.rawItem.arguments, params.rawItem.input, params.rawItem.args));
+    const output = providerContentItemsToValue(firstDefined(params.data.output, params.data.result, params.rawParams.output, result.output, result.value, result.contentItems, params.raw.output, params.raw.result, params.rawItem.output, params.rawItem.result));
+    const errorText = firstString(params.data.error, asRecord(params.data.error).message, params.rawParams.errorText, params.rawParams.error, rawError.message, result.errorText, result.error, resultError.message, params.rawItem.errorText, params.rawItem.error, rawItemError.message, asRecord(params.raw.error).message);
+    return {
+        actionCallId,
+        actionName,
+        input,
+        output,
+        errorText,
+    };
+}
 function readActionInputDelta(params) {
     return (asString(params.chunk.text) ||
         asString(params.data.text) ||
@@ -278,28 +344,19 @@ export function buildLiveEventFromStepChunks(params) {
             const raw = asRecord(chunk.raw);
             const rawParams = asRecord(raw.params);
             const rawItem = asRecord(rawParams.item);
+            const providerAction = readProviderActionDetails({
+                data,
+                raw,
+                rawParams,
+                rawItem,
+            });
             const actionRef = asString(chunk.actionRef) ||
                 asString(chunk.providerPartId) ||
-                asString(data.actionCallId) ||
-                asString(data.toolCallId) ||
-                asString(data.callId) ||
-                asString(data.itemId) ||
-                asString(data.id) ||
-                asString(rawParams.callId) ||
-                asString(rawParams.itemId) ||
-                asString(rawItem.id) ||
-                asString(raw.toolCallId) ||
-                asString(raw.id);
+                providerAction.actionCallId;
             if (!actionRef)
                 continue;
-            const toolName = asString(data.actionName) ||
-                asString(data.toolName) ||
-                asString(rawParams.tool) ||
-                asString(rawItem.command ? "sandbox_run_command" : "") ||
-                asString(raw.actionName) ||
-                asString(raw.toolName) ||
-                asString(raw.name) ||
-                actionParts.get(actionRef)?.toolName ||
+            const actionName = providerAction.actionName ||
+                actionParts.get(actionRef)?.actionName ||
                 "reactorAction";
             const previous = actionParts.get(actionRef);
             const inputDeltaText = readActionInputDelta({
@@ -318,22 +375,13 @@ export function buildLiveEventFromStepChunks(params) {
                 ? `${previous?.inputDeltaText ?? ""}${inputDeltaText}`
                 : previous?.inputDeltaText ?? "";
             const parsedInputDelta = parseActionInputText(nextInputDeltaText);
-            const input = data.input ??
-                data.arguments ??
-                raw.input ??
-                raw.args ??
-                raw.arguments ??
-                rawParams.arguments ??
+            const input = providerAction.input ??
                 (nextInputDeltaText ? parsedInputDelta : undefined) ??
                 previous?.input;
             const nextOutputDeltaText = chunkType === "chunk.action_completed" && outputDeltaText
                 ? `${previous?.outputDeltaText ?? ""}${outputDeltaText}`
                 : previous?.outputDeltaText ?? "";
-            const output = data.output ??
-                data.result ??
-                rawParams.result ??
-                raw.output ??
-                raw.result ??
+            const output = providerAction.output ??
                 (nextOutputDeltaText
                     ? {
                         text: nextOutputDeltaText,
@@ -348,7 +396,7 @@ export function buildLiveEventFromStepChunks(params) {
                     chunkType === "chunk.action_failed"
                     ? sequence
                     : previous?.terminalSequence,
-                toolName,
+                actionName,
                 hasStarted: previous?.hasStarted ||
                     chunkType === "chunk.action_started" ||
                     chunkType === "chunk.action_input_delta",
@@ -365,11 +413,7 @@ export function buildLiveEventFromStepChunks(params) {
                 errorText: chunkType === "chunk.action_failed"
                     ? asString(chunk.text) ||
                         asString(data.text) ||
-                        asString(data.error) ||
-                        asString(asRecord(data.error).message) ||
-                        asString(rawParams.error) ||
-                        asString(asRecord(rawParams.error).message) ||
-                        asString(asRecord(raw.error).message) ||
+                        providerAction.errorText ||
                         undefined
                     : previous?.errorText,
                 terminalStatus: chunkType === "chunk.action_failed"
@@ -415,7 +459,7 @@ export function buildLiveEventFromStepChunks(params) {
                     type: "action",
                     content: {
                         status: "started",
-                        actionName: action.toolName,
+                        actionName: action.actionName,
                         actionCallId: toolCallId,
                         input: action.input ?? {},
                     },
@@ -429,7 +473,7 @@ export function buildLiveEventFromStepChunks(params) {
                     type: "action",
                     content: {
                         status: "completed",
-                        actionName: action.toolName,
+                        actionName: action.actionName,
                         actionCallId: toolCallId,
                         output: action.output ?? {},
                     },
@@ -443,7 +487,7 @@ export function buildLiveEventFromStepChunks(params) {
                     type: "action",
                     content: {
                         status: "failed",
-                        actionName: action.toolName,
+                        actionName: action.actionName,
                         actionCallId: toolCallId,
                         error: {
                             message: action.errorText || "Action failed.",

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

@@ -1,11 +1,11 @@
 import type { ContextEnvironment } from "../context.config.js";
-import type { DomainSchemaResult } from "@ekairos/domain";
+import type { DomainLike } 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, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>, Config = unknown> = {
+export type CreateAiSdkReactorOptions<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>, Config = unknown> = {
     resolveConfig?: (params: {
         runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
         context: StoredContext<Context>;
@@ -33,4 +33,4 @@ export type CreateAiSdkReactorOptions<Context = unknown, Env extends ContextEnvi
         config: Config;
     }) => Promise<number> | number;
 };
-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>;
+export declare function createAiSdkReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = 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

@@ -46,7 +46,6 @@ export function createAiSdkReactor(options) {
             iteration: params.iteration,
             maxSteps,
             sendStart: params.sendStart,
-            silent: params.silent,
             contextStepStream: params.contextStepStream,
             writable: params.writable,
             executionId: params.executionId,
@@ -55,9 +54,9 @@ export function createAiSdkReactor(options) {
         });
         return {
             assistantEvent: result.assistantEvent,
-            actionRequests: result.toolCalls.map((entry) => ({
-                actionRef: String(entry.toolCallId),
-                actionName: String(entry.toolName),
+            actionRequests: result.actionCalls.map((entry) => ({
+                actionRef: String(entry.actionCallId),
+                actionName: String(entry.actionName),
                 input: entry.args,
             })),
             messagesForModel: result.messagesForModel,

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

@@ -24,7 +24,6 @@ export declare function executeAiSdkReaction<Env extends ContextEnvironment = Co
     iteration?: number;
     maxSteps: number;
     sendStart?: boolean;
-    silent?: boolean;
     contextStepStream?: WritableStream<string>;
     writable?: WritableStream<UIMessageChunk>;
     executionId?: string;
@@ -32,7 +31,7 @@ export declare function executeAiSdkReaction<Env extends ContextEnvironment = Co
     stepId?: string;
 }): Promise<{
     assistantEvent: ContextItem;
-    toolCalls: any[];
+    actionCalls: any[];
     messagesForModel: ModelMessage[];
     llm?: {
         provider?: string;

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

@@ -102,7 +102,7 @@ export async function executeAiSdkReaction(params) {
         throw error;
     }
     const { jsonSchema, gateway, smoothStream, stepCountIs, streamText } = await import("ai");
-    const { extractToolCallsFromParts } = await import("../context.toolcalls.js");
+    const { extractActionCallsFromParts } = await import("../context.action-calls.js");
     const resolvedModel = typeof params.model === "string"
         ? gateway(params.model)
         : typeof params.model === "function"
@@ -233,7 +233,7 @@ export async function executeAiSdkReaction(params) {
     }
     const assistantEvent = await finishPromise;
     const finishedAtMs = Date.now();
-    const toolCalls = extractToolCallsFromParts(assistantEvent?.content?.parts);
+    const actionCalls = extractActionCallsFromParts(assistantEvent?.content?.parts);
     const latencyMs = Math.max(0, finishedAtMs - startedAtMs);
     let usage = undefined;
     let providerMetadata = undefined;
@@ -347,5 +347,5 @@ export async function executeAiSdkReaction(params) {
     catch {
         // tracing must not break reaction
     }
-    return { assistantEvent, toolCalls, messagesForModel, llm };
+    return { assistantEvent, actionCalls, messagesForModel, llm };
 }

package/dist/reactors/scripted.reactor.d.ts

@@ -1,5 +1,5 @@
 import type { ModelMessage } from "ai";
-import type { DomainSchemaResult } from "@ekairos/domain";
+import type { DomainLike } from "@ekairos/domain";
 import type { ContextEnvironment } from "../context.config.js";
 import type { ContextRuntime } from "../context.runtime.js";
 import type { ContextItem } from "../context.store.js";
@@ -11,10 +11,10 @@ type ScriptedReactionPayload = {
     messagesForModel?: ModelMessage[];
     llm?: ContextReactionLLM;
 };
-export type ScriptedReactorStep<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = ScriptedReactionPayload | ((params: ContextReactorParams<Context, Env, RequiredDomain, Runtime>) => Promise<ScriptedReactionPayload> | ScriptedReactionPayload);
-export type CreateScriptedReactorOptions<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
+export type ScriptedReactorStep<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = ScriptedReactionPayload | ((params: ContextReactorParams<Context, Env, RequiredDomain, Runtime>) => Promise<ScriptedReactionPayload> | ScriptedReactionPayload);
+export type CreateScriptedReactorOptions<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
     steps: ScriptedReactorStep<Context, Env, RequiredDomain, Runtime>[];
     repeatLast?: boolean;
 };
-export declare function createScriptedReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>>(options: CreateScriptedReactorOptions<Context, Env, RequiredDomain, Runtime>): ContextReactor<Context, Env, RequiredDomain, Runtime>;
+export declare function createScriptedReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>>(options: CreateScriptedReactorOptions<Context, Env, RequiredDomain, Runtime>): ContextReactor<Context, Env, RequiredDomain, Runtime>;
 export {};

package/dist/reactors/types.d.ts

@@ -1,10 +1,10 @@
 import type { ModelMessage, UIMessageChunk } from "ai";
-import type { DomainSchemaResult } from "@ekairos/domain";
+import type { DomainLike } from "@ekairos/domain";
 import type { ContextEnvironment } from "../context.config.js";
 import type { ContextTool } from "../context.action.js";
 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 type { ContextIdentifier, StoredContext, StoredContextResource, ContextItem } from "../context.store.js";
 import type { ContextSkillPackage } from "../context.skill.js";
 import { eventsDomain } from "../schema.js";
 export type ContextActionRequest = {
@@ -34,10 +34,11 @@ export type ContextReactionResult = {
         state?: Record<string, unknown> | null;
     };
 };
-export type ContextReactorParams<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = any> = {
+export type ContextReactorParams<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = any> = {
     runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
     context: StoredContext<Context>;
     contextIdentifier: ContextIdentifier;
+    resources: StoredContextResource[];
     /**
      * Context items after the engine-level expansion stage.
      *
@@ -59,9 +60,8 @@ export type ContextReactorParams<Context = unknown, Env extends ContextEnvironme
     iteration: number;
     maxModelSteps: number;
     sendStart: boolean;
-    silent: boolean;
     contextStepStream?: WritableStream<string>;
     writable?: WritableStream<UIMessageChunk>;
     persistReactionParts?: (parts: any[]) => Promise<void>;
 };
-export type ContextReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = any> = (params: ContextReactorParams<Context, Env, RequiredDomain, Runtime>) => Promise<ContextReactionResult>;
+export type ContextReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = any> = (params: ContextReactorParams<Context, Env, RequiredDomain, Runtime>) => Promise<ContextReactionResult>;

package/dist/schema.d.ts

@@ -6,6 +6,9 @@ export declare const eventsDomain: import("@ekairos/domain").DomainSchemaResult<
         name: import("@instantdb/core").DataAttrDef<string, false, false, false>;
         status: import("@instantdb/core").DataAttrDef<string, false, true, false>;
         content: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+        description: import("@instantdb/core").DataAttrDef<string, false, false, false>;
+        goal: import("@instantdb/core").DataAttrDef<string, false, false, false>;
+        resources: import("@instantdb/core").DataAttrDef<any, false, false, false>;
         reactor: import("@instantdb/core").DataAttrDef<any, false, false, false>;
     }, {}, unknown>;
     event_items: import("@instantdb/core").EntityDef<{

package/dist/schema.js

@@ -10,6 +10,9 @@ export const eventsDomain = domain("events")
             name: i.string().optional(),
             status: i.string().optional().indexed(), // open_idle | open_streaming | closed
             content: i.any().optional(),
+            description: i.string().optional(),
+            goal: i.string().optional(),
+            resources: i.any().optional(),
             reactor: i.json().optional(),
         }),
         event_items: i.entity({

package/dist/steps/do-context-stream-step.js

@@ -12,7 +12,7 @@ export async function doContextStreamStep(params) {
     const { getWritable } = await import("workflow");
     const writable = getWritable();
     const { jsonSchema, gateway, smoothStream, stepCountIs, streamText } = await import("ai");
-    const { extractToolCallsFromParts } = await import("../context.toolcalls.js");
+    const { extractActionCallsFromParts } = await import("../context.action-calls.js");
     // Match DurableAgent's model init behavior:
     // - string => AI Gateway model id, resolved via `gateway(...)` in the step runtime
     // - function => model factory (should be a `"use step"` function for workflow serialization)
@@ -82,9 +82,9 @@ export async function doContextStreamStep(params) {
     }));
     await uiStream.pipeTo(writable, { preventClose: true });
     const assistantEvent = await finishPromise;
-    const actionRequests = extractToolCallsFromParts(assistantEvent?.content?.parts).map((entry) => ({
-        actionRef: String(entry.toolCallId),
-        actionName: String(entry.toolName),
+    const actionRequests = extractActionCallsFromParts(assistantEvent?.content?.parts).map((entry) => ({
+        actionRef: String(entry.actionCallId),
+        actionName: String(entry.actionName),
         input: entry.args,
     }));
     return {

package/dist/steps/store.steps.d.ts

@@ -1,7 +1,6 @@
-import type { UIMessageChunk } from "ai";
 import type { ContextEnvironment } from "../context.config.js";
 import type { ContextRuntime } from "../context.runtime.js";
-import type { ContextExecution, ContextItem, ContextIdentifier, StoredContext, ContextStatus } from "../context.store.js";
+import type { ContextExecution, ContextItem, ContextIdentifier, ContextResource, StoredContextResource, StoredContext, ContextStatus } from "../context.store.js";
 import type { ContextStreamEvent } from "../context.stream.js";
 import { type ContextActionResultForStream, type PersistedContextStepStreamSession } from "./stream.steps.js";
 type RuntimeParams<Env extends ContextEnvironment = ContextEnvironment> = {
@@ -22,10 +21,6 @@ type ContextStepPatch = {
  */
 export declare function initializeContext<C>(params: RuntimeParams & {
     contextIdentifier: ContextIdentifier | null;
-    opts?: {
-        silent?: boolean;
-        writable?: WritableStream<UIMessageChunk>;
-    };
 }): Promise<{
     context: StoredContext<C>;
     isNew: boolean;
@@ -34,6 +29,17 @@ export declare function updateContextContent<C>(params: RuntimeParams & {
     contextIdentifier: ContextIdentifier;
     content: C;
 }): Promise<StoredContext<C>>;
+export declare function updateContextDefinition<C>(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+    definition: {
+        description?: string | null;
+        goal?: string | null;
+    };
+}): Promise<StoredContext<C>>;
+export declare function upsertContextResources(params: RuntimeParams & {
+    contextIdentifier: ContextIdentifier;
+    resources: ContextResource[];
+}): Promise<StoredContextResource[]>;
 export declare function updateContextReactor<C>(params: RuntimeParams & {
     contextIdentifier: ContextIdentifier;
     reactor: {

package/dist/steps/store.steps.js

@@ -143,6 +143,16 @@ export async function updateContextContent(params) {
     const { runtime } = await getRuntimeAndEnv(params);
     return await runtime.store.updateContextContent(params.contextIdentifier, params.content);
 }
+export async function updateContextDefinition(params) {
+    "use step";
+    const { runtime } = await getRuntimeAndEnv(params);
+    return await runtime.store.updateContextDefinition(params.contextIdentifier, params.definition);
+}
+export async function upsertContextResources(params) {
+    "use step";
+    const { runtime } = await getRuntimeAndEnv(params);
+    return await runtime.store.upsertContextResources(params.contextIdentifier, params.resources);
+}
 export async function updateContextReactor(params) {
     "use step";
     const { runtime } = await getRuntimeAndEnv(params);

package/dist/stores/instant.store.d.ts

@@ -1,7 +1,7 @@
 import "../polyfills/dom-events.js";
-import type { DomainSchemaResult } from "@ekairos/domain";
+import type { DomainLike } from "@ekairos/domain";
 import type { ModelMessage } from "ai";
-import type { ContextItem, ContextIdentifier, ContextStatus, StoredContext, ContextStore } from "../context.store.js";
+import type { ContextItem, ContextIdentifier, ContextResource, ContextStatus, StoredContextResource, StoredContext, ContextStore } from "../context.store.js";
 export { parseAndStoreDocument } from "./instant.document-parser.js";
 export { coerceDocumentTextPages, expandEventsWithInstantDocuments, } from "./instant.documents.js";
 export type InstantStoreDb = any;
@@ -14,12 +14,20 @@ export declare class InstantStore implements ContextStore {
     getOrCreateContext<C>(contextIdentifier: ContextIdentifier | null): Promise<StoredContext<C>>;
     getContext<C>(contextIdentifier: ContextIdentifier): Promise<StoredContext<C> | null>;
     updateContextContent<C>(contextIdentifier: ContextIdentifier, content: C): Promise<StoredContext<C>>;
+    updateContextDefinition<C>(contextIdentifier: ContextIdentifier, definition: {
+        description?: string | null;
+        goal?: string | null;
+    }): Promise<StoredContext<C>>;
     updateContextReactor<C>(contextIdentifier: ContextIdentifier, reactor: {
         kind: string;
         state?: Record<string, unknown> | null;
     }): Promise<StoredContext<C>>;
     updateContextStatus(contextIdentifier: ContextIdentifier, status: ContextStatus): Promise<void>;
     private resolveContext;
+    private normalizeContextResource;
+    private normalizeContextResources;
+    getContextResources(contextIdentifier: ContextIdentifier): Promise<StoredContextResource[]>;
+    upsertContextResources(contextIdentifier: ContextIdentifier, resources: ContextResource[]): Promise<StoredContextResource[]>;
     saveItem(contextIdentifier: ContextIdentifier, event: ContextItem): Promise<ContextItem>;
     updateItem(eventId: string, event: ContextItem): Promise<ContextItem>;
     getItem(eventId: string): Promise<ContextItem | null>;
@@ -54,7 +62,7 @@ export declare class InstantStore implements ContextStore {
 export declare function createInstantStoreRuntime(params: {
     getDb: (orgId: string) => Promise<InstantStoreDb> | InstantStoreDb;
     getOrgId?: (env: Record<string, unknown>) => string;
-    domain?: DomainSchemaResult;
+    domain?: DomainLike;
 }): (env: Record<string, unknown>) => Promise<{
     store: InstantStore;
     db: InstantStoreDb;