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

package/dist/context.engine.d.ts

@@ -1,14 +1,14 @@
 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, ContextRuntimeForDomain } from "./context.runtime.js";
 import { eventsDomain } from "./schema.js";
-import type { ContextExecution, ContextItem, ContextIdentifier, StoredContext } from "./context.store.js";
+import type { ContextExecution, ContextItem, ContextIdentifier, ContextResource, StoredContext } from "./context.store.js";
 import type { ContextSkillPackage } from "./context.skill.js";
 import { type ContextReactor } from "./context.reactor.js";
 import { getClientResumeHookUrl, toolApprovalHookToken, toolApprovalWebhookToken } from "./context.hooks.js";
-export interface ContextOptions<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain> {
+export interface ContextOptions<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain> {
     onContextCreated?: (args: {
         env: Env;
         runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
@@ -28,7 +28,7 @@ type ContextBenchmarkRecorder = {
     add?(name: string, value: number): void;
     getCurrentStage?(): string | undefined;
 };
-export declare function runContextReactionDirect<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>>(context: ContextEngine<Context, Env, RequiredDomain>, triggerEvent: ContextItem, params: ContextReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context>>;
+export declare function runContextReactionDirect<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>>(context: ContextEngine<Context, Env, RequiredDomain>, triggerEvent: ContextItem, params: ContextReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context>>;
 export interface ContextStreamOptions {
     /**
      * Maximum loop iterations (LLM call → tool execution → repeat).
@@ -50,14 +50,6 @@ export interface ContextStreamOptions {
      * Default: true.
      */
     sendFinish?: boolean;
-    /**
-     * If true, the story loop runs silently (no UI streaming output).
-     *
-     * Persistence (contexts/events/executions) still happens normally.
-     *
-     * Default: false.
-     */
-    silent?: boolean;
     /**
      * Optional writable stream used by direct/non-durable execution.
      *
@@ -73,7 +65,7 @@ export interface ContextStreamOptions {
  *   be a `"use-step"` function (so it can be serialized by reference).
  */
 export type ContextModelInit = string | (() => Promise<any>);
-export type ContextReactParams<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
+export type ContextReactParams<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
     runtime: ContextRuntimeForDomain<Runtime, RequiredDomain>;
     /**
      * Context selector (exclusive: `{ id }` OR `{ key }`).
@@ -98,10 +90,10 @@ export type ContextReactParams<Env extends ContextEnvironment = ContextEnvironme
     __initialContent?: unknown;
     __benchmark?: ContextBenchmarkRecorder;
 };
-export type ContextDurableReactParams<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = Omit<ContextReactParams<Env, RequiredDomain, Runtime>, "durable"> & {
+export type ContextDurableReactParams<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = Omit<ContextReactParams<Env, RequiredDomain, Runtime>, "durable"> & {
     durable?: true | undefined;
 };
-export type ContextDirectReactParams<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = Omit<ContextReactParams<Env, RequiredDomain, Runtime>, "durable"> & {
+export type ContextDirectReactParams<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = Omit<ContextReactParams<Env, RequiredDomain, Runtime>, "durable"> & {
     durable: false;
 };
 export type ContextReactBase<Context = any> = {
@@ -125,7 +117,7 @@ export type ContextReactRun<Context = any> = ContextWorkflowRun<Context> | Conte
 export type ContextReactResult<Context = any, Run extends ContextReactRun<Context> = ContextReactRun<Context>> = ContextReactBase<Context> & {
     run?: Run;
 };
-export type ContextDurableWorkflowPayload<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
+export type ContextDurableWorkflowPayload<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
     contextKey: string;
     runtime: ContextRuntimeForDomain<Runtime, RequiredDomain>;
     context?: ContextIdentifier | null;
@@ -133,8 +125,8 @@ export type ContextDurableWorkflowPayload<Env extends ContextEnvironment = Conte
     options?: Omit<ContextStreamOptions, "writable">;
     bootstrap: NonNullable<ContextReactParams<Env, RequiredDomain, Runtime>["__bootstrap"]>;
 };
-export type ContextDurableWorkflowFunction<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = (payload: ContextDurableWorkflowPayload<Env, RequiredDomain, Runtime>) => Promise<ContextReactFinalResult<Context>>;
-export type ContextToolExecuteContext<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
+export type ContextDurableWorkflowFunction<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = (payload: ContextDurableWorkflowPayload<Env, RequiredDomain, Runtime>) => Promise<ContextReactFinalResult<Context>>;
+export type ContextToolExecuteContext<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
     runtime: ContextRuntimeForDomain<Runtime, RequiredDomain>;
     context: StoredContext<Context>;
     contextIdentifier: ContextIdentifier;
@@ -168,7 +160,7 @@ export { toolApprovalHookToken, toolApprovalWebhookToken, getClientResumeHookUrl
  * (No imports required in callers.)
  */
 export type ShouldContinue = boolean;
-export type ContextShouldContinueArgs<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain> = {
+export type ContextShouldContinueArgs<Context = any, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain> = {
     env: Env;
     runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
     context: StoredContext<Context>;
@@ -199,12 +191,15 @@ export type ContextShouldContinueArgs<Context = any, Env extends ContextEnvironm
         errorText?: string;
     }>;
 };
-export declare abstract class ContextEngine<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain> {
+export declare abstract class ContextEngine<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain> {
     protected readonly opts: ContextOptions<Context, Env, RequiredDomain>;
     private readonly reactor;
     constructor(opts?: ContextOptions<Context, Env, RequiredDomain>, reactor?: ContextReactor<Context, Env, RequiredDomain>);
     protected abstract initialize(context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>): Promise<Context> | Context;
     protected abstract buildSystemPrompt(context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>): Promise<string> | string;
+    protected describeContext(_content: Context, _context: StoredContext<Context>, _env: Env, _runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>): Promise<string | null>;
+    protected defineGoal(_content: Context, _context: StoredContext<Context>, _env: Env, _runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>): Promise<string | null>;
+    protected defineResources(_content: Context, _context: StoredContext<Context>, _env: Env, _runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>): Promise<ContextResource[]>;
     protected abstract buildTools(context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>): Promise<Record<string, ContextTool<Context, Env, RequiredDomain>>> | Record<string, ContextTool<Context, Env, RequiredDomain>>;
     protected buildSkills(_context: StoredContext<Context>, _env: Env, _runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>): Promise<ContextSkillPackage[]>;
     /**
@@ -241,7 +236,7 @@ export declare abstract class ContextEngine<Context, Env extends ContextEnvironm
     react<Runtime extends ContextRuntime<Env>>(triggerEvent: ContextItem, params: ContextReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context>>;
     private static prepareExecutionShell;
     private static startDurable;
-    static runDirect<Context, Env extends ContextEnvironment, RequiredDomain extends DomainSchemaResult, Runtime extends ContextRuntime<Env>>(story: ContextEngine<Context, Env, RequiredDomain>, triggerEvent: ContextItem, params: ContextReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context, ContextDirectRun<Context>>>;
+    static runDirect<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike, Runtime extends ContextRuntime<Env>>(story: ContextEngine<Context, Env, RequiredDomain>, triggerEvent: ContextItem, params: ContextReactParams<Env, RequiredDomain, Runtime>): Promise<ContextReactResult<Context, ContextDirectRun<Context>>>;
     /**
      * @deprecated Use `react()` instead. Kept for backwards compatibility.
      */

package/dist/context.engine.js

@@ -1,10 +1,10 @@
 import { getContextRuntimeServices } from "./context.runtime.js";
 import { OUTPUT_ITEM_TYPE, WEB_CHANNEL } from "./context.events.js";
-import { applyToolExecutionResultToParts } from "./context.toolcalls.js";
+import { applyActionExecutionResultToParts } from "./context.action-calls.js";
 import { isContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
 import { createAiSdkReactor, } from "./context.reactor.js";
 import { abortPersistedContextStepStream, closeContextStream, createPersistedContextStepStreamForRuntime, finalizePersistedContextStepStreamForRuntime, writeActionResultPartChunksToSession, } from "./steps/stream.steps.js";
-import { completeExecution, completeExecutionStep, createContextStep, getContextItems, initializeContext, openExecutionStep, openExecution, saveExecutionStepOutput, updateContextContent, updateContextReactor, updateContextStatus, updateItem, updateContextStep, updateExecutionWorkflowRun, } from "./steps/store.steps.js";
+import { completeExecution, completeExecutionStep, createContextStep, getContextItems, initializeContext, openExecutionStep, openExecution, saveExecutionStepOutput, updateContextContent, updateContextDefinition, updateContextReactor, updateContextStatus, updateItem, updateContextStep, updateExecutionWorkflowRun, upsertContextResources, } from "./steps/store.steps.js";
 import { readContextDurableWorkflowReturnValue, readContextDurableWorkflowStatus, resumeContextReturnValueHook, startContextDurableWorkflow, } from "./steps/durable.steps.js";
 import { getClientResumeHookUrl, toolApprovalHookToken, toolApprovalWebhookToken, } from "./context.hooks.js";
 import { getContextDurableWorkflow } from "./context.durable.js";
@@ -188,6 +188,8 @@ async function createRuntimeOps(runtimeHandle, benchmark) {
             return { context, isNew: true };
         },
         updateContextContent: async (contextIdentifier, content) => await store.updateContextContent(contextIdentifier, content),
+        updateContextDefinition: async (contextIdentifier, definition) => await store.updateContextDefinition(contextIdentifier, definition),
+        upsertContextResources: async (contextIdentifier, resources) => await store.upsertContextResources(contextIdentifier, resources),
         updateContextReactor: async (contextIdentifier, reactor) => await store.updateContextReactor(contextIdentifier, reactor),
         updateContextStatus: async (contextIdentifier, status) => await instrumentedDb.transact([
             instrumentedDb.tx.event_contexts[requireContextId(contextIdentifier)].update({
@@ -390,8 +392,10 @@ async function createRuntimeOps(runtimeHandle, benchmark) {
 async function createWorkflowOps(runtime) {
     const env = runtime.env;
     return {
-        initializeContext: async (contextIdentifier, opts) => await initializeContext({ runtime, contextIdentifier, opts }),
+        initializeContext: async (contextIdentifier) => await initializeContext({ runtime, contextIdentifier }),
         updateContextContent: async (contextIdentifier, content) => await updateContextContent({ runtime, contextIdentifier, content }),
+        updateContextDefinition: async (contextIdentifier, definition) => await updateContextDefinition({ runtime, contextIdentifier, definition }),
+        upsertContextResources: async (contextIdentifier, resources) => await upsertContextResources({ runtime, contextIdentifier, resources }),
         updateContextReactor: async (contextIdentifier, reactor) => await updateContextReactor({ runtime, contextIdentifier, reactor }),
         updateContextStatus: async (contextIdentifier, status) => await updateContextStatus({ runtime, contextIdentifier, status }),
         openExecution: async ({ contextIdentifier, triggerEvent }) => await openExecution({ runtime, contextIdentifier, triggerEvent }),
@@ -420,6 +424,15 @@ export class ContextEngine {
             reactor ??
                 createAiSdkReactor();
     }
+    async describeContext(_content, _context, _env, _runtime) {
+        return null;
+    }
+    async defineGoal(_content, _context, _env, _runtime) {
+        return null;
+    }
+    async defineResources(_content, _context, _env, _runtime) {
+        return [];
+    }
     async buildSkills(_context, _env, _runtime) {
         return [];
     }
@@ -470,8 +483,7 @@ export class ContextEngine {
         const runtimeHandle = await resolveReactRuntime(params);
         const env = runtimeHandle.env;
         const ops = await measureBenchmark(params.__benchmark, "react.resolveOpsMs", async () => await getContextEngineOps(runtimeHandle, params.__benchmark));
-        const silent = params.options?.silent ?? false;
-        const ctxResult = await measureBenchmark(params.__benchmark, "react.initializeContextMs", async () => await ops.initializeContext(params.context ?? null, { silent }));
+        const ctxResult = await measureBenchmark(params.__benchmark, "react.initializeContextMs", async () => await ops.initializeContext(params.context ?? null));
         let currentContext = ctxResult.context;
         const contextSelector = { id: String(currentContext.id) };
         if (ctxResult.isNew) {
@@ -566,7 +578,6 @@ export class ContextEngine {
                     maxModelSteps: params.options?.maxModelSteps,
                     preventClose: params.options?.preventClose,
                     sendFinish: params.options?.sendFinish,
-                    silent: params.options?.silent,
                 },
                 bootstrap: {
                     contextId: shell.currentContext.id,
@@ -634,7 +645,6 @@ export class ContextEngine {
         const maxModelSteps = params.options?.maxModelSteps ?? 1;
         const preventClose = params.options?.preventClose ?? false;
         const sendFinish = params.options?.sendFinish ?? true;
-        const silent = params.options?.silent ?? false;
         const writable = params.options?.writable;
         const bootstrapped = params.__bootstrap;
         const returnValueHookToken = bootstrapped?.returnValueHookToken ?? null;
@@ -649,7 +659,7 @@ export class ContextEngine {
         const shell = bootstrapped
             ? {
                 contextSelector: { id: String(bootstrapped.contextId) },
-                currentContext: (await measureBenchmark(params.__benchmark, "react.bootstrapContextLookupMs", async () => await ops.initializeContext({ id: String(bootstrapped.contextId) }, { silent }))).context,
+                currentContext: (await measureBenchmark(params.__benchmark, "react.bootstrapContextLookupMs", async () => await ops.initializeContext({ id: String(bootstrapped.contextId) }))).context,
                 trigger: bootstrapped.trigger,
                 reaction: bootstrapped.reaction,
                 execution: bootstrapped.execution,
@@ -672,7 +682,6 @@ export class ContextEngine {
                 execution = { ...execution, status: "failed" };
                 updatedContext = { ...updatedContext, status: "closed" };
                 await emitContextEvents({
-                    silent,
                     writable,
                     events: [
                         {
@@ -695,9 +704,7 @@ export class ContextEngine {
                 // noop
             }
             try {
-                if (!silent) {
-                    await closeContextStream({ preventClose, sendFinish, writable });
-                }
+                await closeContextStream({ preventClose, sendFinish, writable });
             }
             catch {
                 // noop
@@ -706,6 +713,13 @@ export class ContextEngine {
         try {
             for (let iter = 0; iter < maxIterations; iter++) {
                 const stagePrefix = `react.iteration.${iter}`;
+                runtimeHandle.__ekairosContextRun = {
+                    contextId: currentContext.id,
+                    executionId,
+                    triggerEventId,
+                    reactionEventId,
+                    iteration: iter,
+                };
                 // Hook: Context DSL `context()` (implemented by subclasses via `initialize()`)
                 const nextContent = await measureBenchmark(params.__benchmark, `${stagePrefix}.contextMs`, async () => await story.initialize(updatedContext, env, runtimeHandle));
                 const openedStep = await measureBenchmark(params.__benchmark, `${stagePrefix}.openExecutionStepMs`, async () => await ops.openExecutionStep({
@@ -718,8 +732,36 @@ export class ContextEngine {
                 currentStepStream = openedStep.stream;
                 updatedContext = openedStep.context;
                 const rawEvents = openedStep.events;
+                const previousResources = updatedContext.resources ?? [];
+                const resources = await measureBenchmark(params.__benchmark, `${stagePrefix}.resourcesMs`, async () => await story.defineResources(nextContent, updatedContext, env, runtimeHandle));
+                const shouldPersistResources = resources.length > 0 || previousResources.length > 0;
+                let contextResources = previousResources;
+                if (shouldPersistResources) {
+                    contextResources = await measureBenchmark(params.__benchmark, `${stagePrefix}.contextResourcesMs`, async () => await ops.upsertContextResources(activeContextSelector, resources));
+                    updatedContext = {
+                        ...updatedContext,
+                        resources: contextResources,
+                    };
+                }
+                else {
+                    updatedContext = {
+                        ...updatedContext,
+                        resources: [],
+                    };
+                }
+                const description = await measureBenchmark(params.__benchmark, `${stagePrefix}.descriptionMs`, async () => await story.describeContext(nextContent, updatedContext, env, runtimeHandle));
+                const goal = await measureBenchmark(params.__benchmark, `${stagePrefix}.goalMs`, async () => await story.defineGoal(nextContent, updatedContext, env, runtimeHandle));
+                if (description !== null || goal !== null) {
+                    updatedContext = await measureBenchmark(params.__benchmark, `${stagePrefix}.contextDefinitionMs`, async () => await ops.updateContextDefinition(activeContextSelector, {
+                        ...(description !== null ? { description } : {}),
+                        ...(goal !== null ? { goal } : {}),
+                    }));
+                    updatedContext = {
+                        ...updatedContext,
+                        resources: contextResources,
+                    };
+                }
                 await emitContextEvents({
-                    silent,
                     writable,
                     events: [
                         {
@@ -735,6 +777,24 @@ export class ContextEngine {
                             at: nowIso(),
                             contextId: String(updatedContext.id),
                         },
+                        ...(description !== null || goal !== null
+                            ? [
+                                {
+                                    type: "context.definition_updated",
+                                    at: nowIso(),
+                                    contextId: String(updatedContext.id),
+                                },
+                            ]
+                            : []),
+                        ...(shouldPersistResources
+                            ? [
+                                {
+                                    type: "context.resources_updated",
+                                    at: nowIso(),
+                                    contextId: String(updatedContext.id),
+                                },
+                            ]
+                            : []),
                     ],
                 });
                 await story.opts.onContextUpdated?.({
@@ -788,6 +848,7 @@ export class ContextEngine {
                     runtime: runtimeHandle,
                     context: updatedContext,
                     contextIdentifier: activeContextSelector,
+                    resources: contextResources,
                     events: expandedEvents,
                     triggerEvent,
                     model: story.getModel(updatedContext, env, runtimeHandle),
@@ -801,8 +862,7 @@ export class ContextEngine {
                     iteration: iter,
                     maxModelSteps,
                     // Only emit a `start` chunk once per story turn.
-                    sendStart: !silent && iter === 0,
-                    silent,
+                    sendStart: iter === 0,
                     contextStepStream: currentStepStream?.stream,
                     writable,
                     persistReactionParts,
@@ -858,7 +918,6 @@ export class ContextEngine {
                 }));
                 reactionEvent = appendedReactorOutput.reactionEvent;
                 await emitContextEvents({
-                    silent,
                     writable,
                     events: stepParts.map((part, idx) => ({
                         type: "part.created",
@@ -883,7 +942,6 @@ export class ContextEngine {
                 }
                 story.opts.onEventCreated?.(assistantEventEffective);
                 await emitContextEvents({
-                    silent,
                     writable,
                     events: [
                         {
@@ -918,7 +976,6 @@ export class ContextEngine {
                         currentStepId = null;
                         reactionEvent = finalized.reactionEvent ?? completedReactionEvent;
                         await emitContextEvents({
-                            silent,
                             writable,
                             events: [
                                 {
@@ -940,7 +997,6 @@ export class ContextEngine {
                             ],
                         });
                         await emitContextEvents({
-                            silent,
                             writable,
                             events: [
                                 {
@@ -957,7 +1013,6 @@ export class ContextEngine {
                         execution = { ...execution, status: "completed" };
                         updatedContext = { ...updatedContext, status: "closed" };
                         await emitContextEvents({
-                            silent,
                             writable,
                             events: [
                                 {
@@ -975,9 +1030,7 @@ export class ContextEngine {
                                 },
                             ],
                         });
-                        if (!silent) {
-                            await closeContextStream({ preventClose, sendFinish, writable });
-                        }
+                        await closeContextStream({ preventClose, sendFinish, writable });
                         const result = {
                             context: updatedContext,
                             trigger,
@@ -1057,9 +1110,9 @@ export class ContextEngine {
                 // Merge action results into step parts so the next reaction can see them.
                 let finalizedStepParts = Array.isArray(stepParts) ? [...stepParts] : [];
                 for (const r of actionResults) {
-                    finalizedStepParts = applyToolExecutionResultToParts(finalizedStepParts, {
-                        toolCallId: r.actionRequest.actionRef,
-                        toolName: r.actionRequest.actionName,
+                    finalizedStepParts = applyActionExecutionResultToParts(finalizedStepParts, {
+                        actionCallId: r.actionRequest.actionRef,
+                        actionName: r.actionRequest.actionName,
                     }, {
                         success: Boolean(r.success),
                         result: r.output,
@@ -1092,12 +1145,10 @@ export class ContextEngine {
                 currentStepId = null;
                 reactionEvent = completedStep.reactionEvent ?? pendingReactionEvent;
                 await emitContextEvents({
-                    silent,
                     writable,
                     events: completedStep.actionResultChunkEvents,
                 });
                 await emitContextEvents({
-                    silent,
                     writable,
                     events: [
                         {
@@ -1142,7 +1193,6 @@ export class ContextEngine {
                 }));
                 if (continueLoop !== false) {
                     await emitContextEvents({
-                        silent,
                         writable,
                         events: [
                             {
@@ -1162,7 +1212,6 @@ export class ContextEngine {
                         status: "completed",
                     };
                     await emitContextEvents({
-                        silent,
                         writable,
                         events: [
                             {
@@ -1183,7 +1232,6 @@ export class ContextEngine {
                     execution = { ...execution, status: "completed" };
                     updatedContext = { ...updatedContext, status: "closed" };
                     await emitContextEvents({
-                        silent,
                         writable,
                         events: [
                             {
@@ -1201,9 +1249,7 @@ export class ContextEngine {
                             },
                         ],
                     });
-                    if (!silent) {
-                        await closeContextStream({ preventClose, sendFinish, writable });
-                    }
+                    await closeContextStream({ preventClose, sendFinish, writable });
                     const result = {
                         context: updatedContext,
                         trigger,
@@ -1246,7 +1292,6 @@ export class ContextEngine {
                         contextId: String(currentContext.id),
                     }));
                     await emitContextEvents({
-                        silent,
                         writable,
                         events: [
                             {

package/dist/context.parts.js

@@ -216,6 +216,58 @@ function normalizeFileContentBlock(value) {
         fileId: typeof value.fileId === "string" ? value.fileId : undefined,
     }));
 }
+function normalizeInlineContentBlock(value) {
+    const record = asRecord(value);
+    if (!record || typeof record.type !== "string")
+        return null;
+    if (record.type === "text" && typeof record.text === "string") {
+        return contextInlineContentSchema.parse({ type: "text", text: record.text });
+    }
+    if (record.type === "json") {
+        return contextInlineContentSchema.parse({ type: "json", value: record.value });
+    }
+    if (record.type === "file" || record.type === "image-data") {
+        return normalizeFileContentBlock(record);
+    }
+    return null;
+}
+function normalizeInlineContentBlocks(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((block) => normalizeInlineContentBlock(block))
+        .filter((block) => Boolean(block));
+}
+function contentBlocksToActionValue(blocks) {
+    if (blocks.length === 0)
+        return undefined;
+    if (blocks.length === 1) {
+        const [first] = blocks;
+        if (first.type === "json")
+            return first.value;
+        if (first.type === "text")
+            return first.text;
+        if (first.type === "file")
+            return first;
+    }
+    return {
+        type: "content",
+        value: blocks,
+    };
+}
+function contentBlocksToErrorMessage(blocks) {
+    const text = blocks
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("\n\n")
+        .trim();
+    if (text)
+        return text;
+    const jsonBlock = blocks.find((block) => block.type === "json");
+    if (jsonBlock)
+        return JSON.stringify(jsonBlock.value, null, 2);
+    return "";
+}
 function readReactorMetadata(record) {
     const parsed = reactorMetadataSchema.safeParse(record.reactorMetadata);
     return parsed.success ? parsed.data : undefined;
@@ -239,6 +291,62 @@ function messageFromBlocks(blocks, reactorMetadata) {
         })),
     ];
 }
+function normalizeExternalToolCallPart(record, reactorMetadata) {
+    const actionName = typeof record.toolName === "string" && record.toolName.length > 0
+        ? record.toolName
+        : "";
+    const actionCallId = typeof record.toolCallId === "string" && record.toolCallId.length > 0
+        ? record.toolCallId
+        : "";
+    if (!actionName || !actionCallId)
+        return [];
+    const blocks = normalizeInlineContentBlocks(record.content);
+    return [
+        contextActionPartSchema.parse(cleanRecord({
+            type: "action",
+            content: {
+                status: "started",
+                actionName,
+                actionCallId,
+                input: contentBlocksToActionValue(blocks),
+            },
+            reactorMetadata,
+        })),
+    ];
+}
+function normalizeExternalToolResultPart(record, reactorMetadata) {
+    const actionName = typeof record.toolName === "string" && record.toolName.length > 0
+        ? record.toolName
+        : "";
+    const actionCallId = typeof record.toolCallId === "string" && record.toolCallId.length > 0
+        ? record.toolCallId
+        : "";
+    if (!actionName || !actionCallId)
+        return [];
+    const blocks = normalizeInlineContentBlocks(record.content);
+    const failed = record.state === "output-error";
+    return [
+        contextActionPartSchema.parse(cleanRecord({
+            type: "action",
+            content: failed
+                ? {
+                    status: "failed",
+                    actionName,
+                    actionCallId,
+                    error: {
+                        message: contentBlocksToErrorMessage(blocks) || "Action execution failed.",
+                    },
+                }
+                : {
+                    status: "completed",
+                    actionName,
+                    actionCallId,
+                    output: contentBlocksToActionValue(blocks),
+                },
+            reactorMetadata,
+        })),
+    ];
+}
 export function normalizeUiPartToContextPartEnvelopes(value) {
     const record = asRecord(value);
     if (!record || typeof record.type !== "string") {
@@ -307,6 +415,12 @@ export function normalizeUiPartToContextPartEnvelopes(value) {
     if (record.type.startsWith("data-")) {
         return messageFromBlocks([{ type: "json", value: record.data }], reactorMetadata);
     }
+    if (record.type === "tool-call") {
+        return normalizeExternalToolCallPart(record, reactorMetadata);
+    }
+    if (record.type === "tool-result") {
+        return normalizeExternalToolResultPart(record, reactorMetadata);
+    }
     if (record.type.startsWith("tool-")) {
         const actionName = record.type.slice("tool-".length);
         const actionCallId = typeof record.toolCallId === "string" ? record.toolCallId : "";

package/dist/context.runtime.d.ts

@@ -1,4 +1,4 @@
-import type { ActiveDomain, ConcreteDomain, DomainSchemaResult } from "@ekairos/domain";
+import type { ConcreteDomain, DomainLike } from "@ekairos/domain";
 import type { EkairosRuntime, RuntimeForDomain, RuntimeResolveOptions } from "@ekairos/domain/runtime";
 import type { ContextEnvironment } from "./context.config.js";
 import type { ContextStore } from "./context.store.js";
@@ -9,10 +9,10 @@ export type ContextRuntimeServiceHandle = {
     resolve?: (...args: any[]) => Promise<any> | any;
     meta?: (...args: any[]) => Record<string, unknown> | undefined;
 };
-export type ContextRuntimeHandleForDomain<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain> = ContextRuntimeServiceHandle & {
-    use<Subdomain extends typeof eventsDomain | RequiredDomain>(subdomain: Subdomain, options?: RuntimeResolveOptions): Promise<Omit<ActiveDomain<Subdomain, Env>, "env">>;
+export type ContextRuntimeHandleForDomain<Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain> = ContextRuntimeServiceHandle & {
+    use<Subdomain extends typeof eventsDomain | RequiredDomain>(subdomain: Subdomain, options?: RuntimeResolveOptions): Promise<unknown>;
 };
-export type ContextRuntimeForDomain<Runtime extends ContextRuntime<any>, RequiredDomain extends DomainSchemaResult = typeof eventsDomain> = RuntimeForDomain<Runtime, typeof eventsDomain> & RuntimeForDomain<Runtime, RequiredDomain>;
+export type ContextRuntimeForDomain<Runtime extends ContextRuntime<any>, RequiredDomain extends DomainLike = typeof eventsDomain> = RuntimeForDomain<Runtime, typeof eventsDomain> & RuntimeForDomain<Runtime, RequiredDomain>;
 export type ContextRuntimeServices = {
     db: any;
     store: ContextStore;

package/dist/context.store.d.ts

@@ -8,6 +8,50 @@ export type ContextIdentifier = {
     id?: never;
 };
 export type { ContextStatus } from "./context.contract.js";
+export type ContextResourceBase = {
+    key: string;
+    type: string;
+    name: string;
+    description: string;
+    role?: string | null;
+    metadata?: Record<string, unknown> | null;
+};
+export type ContextFileResource = ContextResourceBase & {
+    type: "file";
+    fileId?: string;
+    documentId?: string;
+    url?: string;
+    filename?: string;
+    mediaType?: string;
+    size?: number;
+};
+export type ContextLinkResource = ContextResourceBase & {
+    type: "link";
+    url: string;
+};
+export type ContextRepositoryResource = ContextResourceBase & {
+    type: "repository";
+    provider?: string;
+    repository: string;
+    ref?: string;
+    paths?: string[];
+    commitSha?: string;
+};
+export type ContextDatasetResource = ContextResourceBase & {
+    type: "dataset";
+    datasetId: string;
+};
+export type ContextExternalResource = ContextResourceBase & {
+    type: "external";
+    uri?: string;
+};
+export type ContextResource = ContextFileResource | ContextLinkResource | ContextRepositoryResource | ContextDatasetResource | ContextExternalResource | (ContextResourceBase & Record<string, unknown>);
+export type StoredContextResource = ContextResource & {
+    id?: string;
+    storageKey?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+};
 export type StoredContext<Context> = {
     id: string;
     key: string | null;
@@ -16,6 +60,9 @@ export type StoredContext<Context> = {
     createdAt: Date;
     updatedAt?: Date;
     content: Context | null;
+    description?: string | null;
+    goal?: string | null;
+    resources?: StoredContextResource[] | null;
     reactor?: {
         kind: string;
         state?: Record<string, unknown> | null;
@@ -53,6 +100,12 @@ export interface 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>>;
+    upsertContextResources(contextIdentifier: ContextIdentifier, resources: ContextResource[]): Promise<StoredContextResource[]>;
+    getContextResources(contextIdentifier: ContextIdentifier): Promise<StoredContextResource[]>;
     updateContextReactor<C>(contextIdentifier: ContextIdentifier, reactor: {
         kind: string;
         state?: Record<string, unknown> | null;