@ekairos/events 1.22.83-beta.development.0 → 1.22.85-beta.development.0

package/dist/context.builder.d.ts

@@ -5,13 +5,22 @@ import { ContextEngine, type ContextModelInit, type ContextOptions, type ShouldC
 import type { ContextTool } from "./context.action.js";
 import type { ContextRuntime, ContextRuntimeHandleForDomain } from "./context.runtime.js";
 import type { ContextReactor } from "./context.reactor.js";
-import type { ContextItem, StoredContext } from "./context.store.js";
+import type { ContextItem, ContextResource, StoredContext, StoredContextResource } from "./context.store.js";
 import { type ContextKey } from "./context.registry.js";
 import { eventsDomain } from "./schema.js";
+export type ContextResourcesParams<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain> = {
+    content: Context;
+    context: StoredContext<Context>;
+    env: Env;
+    runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
+};
 export interface ContextConfig<Context, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainLike = typeof eventsDomain> {
     context: (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<Context> | Context;
     expandEvents?: (events: ContextItem[], context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<ContextItem[]> | ContextItem[];
-    narrative: (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<string> | string;
+    narrative?: (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<string> | string;
+    description?: (content: Context, context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<string> | string;
+    goal?: (content: Context, context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<string> | string;
+    resources?: (params: ContextResourcesParams<Context, Env, RequiredDomain>) => Promise<ContextResource[] | StoredContextResource[]> | ContextResource[] | StoredContextResource[];
     skills?: (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<ContextSkillPackage[]> | ContextSkillPackage[];
     actions: (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<Record<string, ContextTool<Context, Env, RequiredDomain>>> | Record<string, ContextTool<Context, Env, RequiredDomain>>;
     /**
@@ -32,6 +41,10 @@ export declare function context<Context, Env extends ContextEnvironment = Contex
 type AnyContextInitializer<Env extends ContextEnvironment, RequiredDomain extends DomainLike> = (context: StoredContext<any>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<any> | any;
 type InferContextFromInitializer<I extends AnyContextInitializer<any, any>> = Awaited<ReturnType<I>>;
 type BuilderSystemPrompt<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike> = (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<string> | string;
+type BuilderDescription<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike> = (content: Context, context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<string> | string;
+type BuilderGoal<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike> = BuilderDescription<Context, Env, RequiredDomain>;
+type BuilderResources<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike> = (params: ContextResourcesParams<Context, Env, RequiredDomain>) => Promise<ContextResource[] | StoredContextResource[] | null> | ContextResource[] | StoredContextResource[] | null;
+type BuilderResource<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike> = ContextResource | StoredContextResource | ((params: ContextResourcesParams<Context, Env, RequiredDomain>) => Promise<ContextResource | StoredContextResource | null | undefined> | ContextResource | StoredContextResource | null | undefined);
 type BuilderSkills<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike> = (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<ContextSkillPackage[]> | ContextSkillPackage[];
 type BuilderTools<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike> = (context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<Record<string, ContextTool<Context, Env, RequiredDomain>>> | Record<string, ContextTool<Context, Env, RequiredDomain>>;
 type BuilderExpandEvents<Context, Env extends ContextEnvironment, RequiredDomain extends DomainLike> = (events: ContextItem[], context: StoredContext<Context>, env: Env, runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>) => Promise<ContextItem[]> | ContextItem[];
@@ -46,6 +59,10 @@ type FluentContextBuilder<Context, Env extends ContextEnvironment, RequiredDomai
     expandEvents(fn: BuilderExpandEvents<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
     narrative(fn: BuilderSystemPrompt<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
     system(fn: BuilderSystemPrompt<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
+    description(fn: BuilderDescription<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
+    goal(fn: BuilderGoal<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
+    resources(fn: BuilderResources<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
+    resource(resource: BuilderResource<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
     skills(fn: BuilderSkills<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
     actions(fn: BuilderTools<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
     tools(fn: BuilderTools<Context, Env, RequiredDomain>): FluentContextBuilder<Context, Env, RequiredDomain>;
@@ -64,6 +81,7 @@ type FluentContextBuilder<Context, Env extends ContextEnvironment, RequiredDomai
     build(): ContextInstance<Context, Env, RequiredDomain>;
 };
 type CreateContextEntry<Env extends ContextEnvironment, RequiredDomain extends DomainLike> = {
+    content<Initializer extends AnyContextInitializer<Env, RequiredDomain>>(initializer: Initializer): FluentContextBuilder<InferContextFromInitializer<Initializer>, Env, RequiredDomain>;
     context<Initializer extends AnyContextInitializer<Env, RequiredDomain>>(initializer: Initializer): FluentContextBuilder<InferContextFromInitializer<Initializer>, Env, RequiredDomain>;
     initialize<Initializer extends AnyContextInitializer<Env, RequiredDomain>>(initializer: Initializer): FluentContextBuilder<InferContextFromInitializer<Initializer>, Env, RequiredDomain>;
 };

package/dist/context.builder.js

@@ -4,6 +4,28 @@ import { eventsDomain } from "./schema.js";
 function isDynamicModelSelector(model) {
     return typeof model === "function" && model.length >= 1;
 }
+function stringifyContextContent(content) {
+    try {
+        return JSON.stringify(content ?? null, null, 2);
+    }
+    catch {
+        return String(content);
+    }
+}
+function buildDefaultContextPrompt(params) {
+    const sections = [];
+    sections.push(`Content:\n${stringifyContextContent(params.content)}`);
+    if (params.resources?.length) {
+        sections.push(`Resources:\n${stringifyContextContent(params.resources)}`);
+    }
+    if (params.description) {
+        sections.push(`Description:\n${params.description}`);
+    }
+    if (params.goal) {
+        sections.push(`Goal:\n${params.goal}`);
+    }
+    return sections.join("\n\n");
+}
 export function context(config) {
     class FunctionalContext extends ContextEngine {
         constructor() {
@@ -21,7 +43,36 @@ export function context(config) {
         async buildSystemPrompt(contextValue, env, runtime) {
             if (config.narrative)
                 return config.narrative(contextValue, env, runtime);
-            throw new Error("Context config is missing narrative()");
+            const content = contextValue.content;
+            const description = contextValue.description ??
+                (config.description
+                    ? await config.description(content, contextValue, env, runtime)
+                    : null);
+            const goal = contextValue.goal ??
+                (config.goal
+                    ? await config.goal(content, contextValue, env, runtime)
+                    : null);
+            return buildDefaultContextPrompt({
+                content,
+                resources: contextValue.resources ?? [],
+                description,
+                goal,
+            });
+        }
+        async describeContext(content, contextValue, env, runtime) {
+            if (!config.description)
+                return null;
+            return config.description(content, contextValue, env, runtime);
+        }
+        async defineGoal(content, contextValue, env, runtime) {
+            if (!config.goal)
+                return null;
+            return config.goal(content, contextValue, env, runtime);
+        }
+        async defineResources(content, contextValue, env, runtime) {
+            if (!config.resources)
+                return [];
+            return config.resources({ content, context: contextValue, env, runtime });
         }
         async buildSkills(contextValue, env, runtime) {
             if (config.skills)
@@ -51,10 +102,10 @@ export function context(config) {
 }
 function assertConfigComplete(config) {
     if (!config.context) {
-        throw new Error("createContext: you must define context() before building the Context.");
+        throw new Error("createContext: you must define content() before building the Context.");
     }
-    if (!config.narrative) {
-        throw new Error("createContext: you must define narrative() before building the Context.");
+    if (!config.narrative && (!config.description || !config.goal)) {
+        throw new Error("createContext: you must define description() and goal() before building the Context.");
     }
     if (!config.actions && !config.tools) {
         throw new Error("createContext: you must define actions() before building the Context.");
@@ -71,6 +122,20 @@ export function createContext(keyOrDomain, maybeKey) {
         const fluentState = {
             context: typedInitializer,
         };
+        const resourceFactories = [];
+        const refreshResourcesConfig = () => {
+            fluentState.resources = async (params) => {
+                const resources = [];
+                for (const factory of resourceFactories) {
+                    const result = await factory(params);
+                    if (!result)
+                        continue;
+                    const list = Array.isArray(result) ? result : [result];
+                    resources.push(...list);
+                }
+                return resources;
+            };
+        };
         let cached = null;
         const getOrBuild = () => {
             assertConfigComplete(fluentState);
@@ -98,6 +163,30 @@ export function createContext(keyOrDomain, maybeKey) {
                 fluentState.narrative = system;
                 return builder;
             },
+            description(description) {
+                fluentState.description = description;
+                return builder;
+            },
+            goal(goal) {
+                fluentState.goal = goal;
+                return builder;
+            },
+            resources(resources) {
+                resourceFactories.push(resources);
+                refreshResourcesConfig();
+                return builder;
+            },
+            resource(resource) {
+                resourceFactories.push(async (params) => {
+                    if (typeof resource === "function") {
+                        const resolved = await resource(params);
+                        return resolved ? [resolved] : [];
+                    }
+                    return [resource];
+                });
+                refreshResourcesConfig();
+                return builder;
+            },
             skills(skillsFactory) {
                 fluentState.skills = skillsFactory;
                 return builder;
@@ -142,6 +231,7 @@ export function createContext(keyOrDomain, maybeKey) {
         return builder;
     };
     return {
+        content: initializeBuilder,
         context: initializeBuilder,
         initialize: initializeBuilder,
     };

package/dist/context.d.ts

@@ -1,5 +1,5 @@
 export { ContextEngine, type ContextOptions, type ContextStreamOptions, type ShouldContinue, type ContextShouldContinueArgs, 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 ContextToolExecuteContext, runContextReactionDirect, } from "./context.engine.js";
-export { context, createContext, type ContextConfig, type ContextInstance, type RegistrableContextBuilder, } from "./context.builder.js";
+export { context, createContext, type ContextConfig, type ContextInstance, type ContextResourcesParams, type RegistrableContextBuilder, } from "./context.builder.js";
 export { defineAction, action, type ContextAction, type ContextActionBase, type ContextActionExecuteParams, type AnyContextAction, type ContextActionDefinition, type ContextActionExecute, type DefineContextActionDefinition, type DefineContextActionExecute, type LegacyContextActionDefinition, type LegacyContextActionExecute, type ContextActionInput, type ContextActionOutput, type ContextProviderDefinedAction, type ContextActionSchema, type ContextTool, } from "./context.action.js";
 export { createAiSdkReactor, createScriptedReactor, type CreateAiSdkReactorOptions, type CreateScriptedReactorOptions, type ScriptedReactorStep, type ContextReactor, type ContextReactorParams, type ContextReactionResult, type ContextActionRequest, type ContextReactionLLM, } from "./context.reactor.js";
 export type { ContextSkillPackage, ContextSkillPackageFile, } from "./context.skill.js";

package/dist/context.engine.d.ts

@@ -4,7 +4,7 @@ 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";
@@ -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.
      *
@@ -205,6 +197,9 @@ export declare abstract class ContextEngine<Context, Env extends ContextEnvironm
     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[]>;
     /**

package/dist/context.engine.js

@@ -4,7 +4,7 @@ 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
@@ -725,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: [
                         {
@@ -742,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?.({
@@ -795,6 +848,7 @@ export class ContextEngine {
                     runtime: runtimeHandle,
                     context: updatedContext,
                     contextIdentifier: activeContextSelector,
+                    resources: contextResources,
                     events: expandedEvents,
                     triggerEvent,
                     model: story.getModel(updatedContext, env, runtimeHandle),
@@ -808,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,
@@ -865,7 +918,6 @@ export class ContextEngine {
                 }));
                 reactionEvent = appendedReactorOutput.reactionEvent;
                 await emitContextEvents({
-                    silent,
                     writable,
                     events: stepParts.map((part, idx) => ({
                         type: "part.created",
@@ -890,7 +942,6 @@ export class ContextEngine {
                 }
                 story.opts.onEventCreated?.(assistantEventEffective);
                 await emitContextEvents({
-                    silent,
                     writable,
                     events: [
                         {
@@ -925,7 +976,6 @@ export class ContextEngine {
                         currentStepId = null;
                         reactionEvent = finalized.reactionEvent ?? completedReactionEvent;
                         await emitContextEvents({
-                            silent,
                             writable,
                             events: [
                                 {
@@ -947,7 +997,6 @@ export class ContextEngine {
                             ],
                         });
                         await emitContextEvents({
-                            silent,
                             writable,
                             events: [
                                 {
@@ -964,7 +1013,6 @@ export class ContextEngine {
                         execution = { ...execution, status: "completed" };
                         updatedContext = { ...updatedContext, status: "closed" };
                         await emitContextEvents({
-                            silent,
                             writable,
                             events: [
                                 {
@@ -982,9 +1030,7 @@ export class ContextEngine {
                                 },
                             ],
                         });
-                        if (!silent) {
-                            await closeContextStream({ preventClose, sendFinish, writable });
-                        }
+                        await closeContextStream({ preventClose, sendFinish, writable });
                         const result = {
                             context: updatedContext,
                             trigger,
@@ -1099,12 +1145,10 @@ export class ContextEngine {
                 currentStepId = null;
                 reactionEvent = completedStep.reactionEvent ?? pendingReactionEvent;
                 await emitContextEvents({
-                    silent,
                     writable,
                     events: completedStep.actionResultChunkEvents,
                 });
                 await emitContextEvents({
-                    silent,
                     writable,
                     events: [
                         {
@@ -1149,7 +1193,6 @@ export class ContextEngine {
                 }));
                 if (continueLoop !== false) {
                     await emitContextEvents({
-                        silent,
                         writable,
                         events: [
                             {
@@ -1169,7 +1212,6 @@ export class ContextEngine {
                         status: "completed",
                     };
                     await emitContextEvents({
-                        silent,
                         writable,
                         events: [
                             {
@@ -1190,7 +1232,6 @@ export class ContextEngine {
                     execution = { ...execution, status: "completed" };
                     updatedContext = { ...updatedContext, status: "closed" };
                     await emitContextEvents({
-                        silent,
                         writable,
                         events: [
                             {
@@ -1208,9 +1249,7 @@ export class ContextEngine {
                             },
                         ],
                     });
-                    if (!silent) {
-                        await closeContextStream({ preventClose, sendFinish, writable });
-                    }
+                    await closeContextStream({ preventClose, sendFinish, writable });
                     const result = {
                         context: updatedContext,
                         trigger,
@@ -1253,7 +1292,6 @@ export class ContextEngine {
                         contextId: String(currentContext.id),
                     }));
                     await emitContextEvents({
-                        silent,
                         writable,
                         events: [
                             {

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;

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,5 +1,5 @@
-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";
@@ -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/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,

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;

package/dist/reactors/types.d.ts

@@ -4,7 +4,7 @@ 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 = {
@@ -38,6 +38,7 @@ export type ContextReactorParams<Context = unknown, Env extends ContextEnvironme
     runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
     context: StoredContext<Context>;
     contextIdentifier: ContextIdentifier;
+    resources: StoredContextResource[];
     /**
      * Context items after the engine-level expansion stage.
      *
@@ -59,7 +60,6 @@ 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>;

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/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 { 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>;

package/dist/stores/instant.store.js

@@ -155,6 +155,9 @@ export class InstantStore {
                     ? new Date(row.updatedAt)
                     : undefined,
             content: row?.content ?? null,
+            description: typeof row?.description === "string" ? row.description : null,
+            goal: typeof row?.goal === "string" ? row.goal : null,
+            resources: this.normalizeContextResources(row?.resources),
             reactor: row?.reactor && typeof row.reactor === "object"
                 ? row.reactor
                 : null,
@@ -184,6 +187,9 @@ export class InstantStore {
                 key,
                 status: "open_idle",
                 content: {},
+                description: undefined,
+                goal: undefined,
+                resources: [],
                 reactor: undefined,
             }),
         ]);
@@ -244,6 +250,28 @@ export class InstantStore {
             throw new Error("InstantStore: context not found after update");
         return updated;
     }
+    async updateContextDefinition(contextIdentifier, definition) {
+        const context = await this.getContext(contextIdentifier);
+        if (!context?.id)
+            throw new Error("InstantStore: context not found");
+        const update = {
+            updatedAt: new Date(),
+        };
+        if (definition.description !== undefined) {
+            update.description =
+                typeof definition.description === "string" ? definition.description : undefined;
+        }
+        if (definition.goal !== undefined) {
+            update.goal = typeof definition.goal === "string" ? definition.goal : undefined;
+        }
+        await this.db.transact([
+            this.db.tx.event_contexts[context.id].update(update),
+        ]);
+        const updated = await this.getContext({ id: context.id });
+        if (!updated)
+            throw new Error("InstantStore: context not found after definition update");
+        return updated;
+    }
     async updateContextReactor(contextIdentifier, reactor) {
         const context = await this.getContext(contextIdentifier);
         if (!context?.id)
@@ -279,6 +307,66 @@ export class InstantStore {
             throw new Error("InstantStore: context not found");
         return context;
     }
+    normalizeContextResource(resource) {
+        if (!resource || typeof resource !== "object")
+            return null;
+        const record = resource;
+        const key = typeof record.key === "string" ? record.key.trim() : "";
+        const type = typeof record.type === "string" ? record.type.trim() : "";
+        const name = typeof record.name === "string" ? record.name.trim() : "";
+        const description = typeof record.description === "string" ? record.description.trim() : "";
+        if (!key || !type || !name || !description)
+            return null;
+        return {
+            ...record,
+            key,
+            type,
+            name,
+            description,
+        };
+    }
+    normalizeContextResources(value) {
+        if (!Array.isArray(value))
+            return [];
+        return value.flatMap((resource) => {
+            const normalized = this.normalizeContextResource(resource);
+            return normalized ? [normalized] : [];
+        });
+    }
+    async getContextResources(contextIdentifier) {
+        const context = await this.resolveContext(contextIdentifier);
+        return context.resources ?? [];
+    }
+    async upsertContextResources(contextIdentifier, resources) {
+        const context = await this.resolveContext(contextIdentifier);
+        const now = new Date();
+        const storedResources = [];
+        for (const resource of resources) {
+            const resourceKey = typeof resource.key === "string" ? resource.key.trim() : "";
+            const type = typeof resource.type === "string" ? resource.type.trim() : "";
+            const name = typeof resource.name === "string" ? resource.name.trim() : "";
+            const description = typeof resource.description === "string" ? resource.description.trim() : "";
+            if (!resourceKey || !type || !name || !description) {
+                throw new Error("InstantStore: context resources require key, type, name, and description.");
+            }
+            const sanitizedResource = sanitizeInstantValue(resource);
+            const storedResource = {
+                ...sanitizedResource,
+                key: resourceKey,
+                type,
+                name,
+                description,
+            };
+            storedResources.push(storedResource);
+        }
+        await this.db.transact([
+            this.db.tx.event_contexts[context.id].update({
+                resources: storedResources,
+                updatedAt: now,
+            }),
+        ]);
+        return await this.getContextResources({ id: context.id });
+    }
     async saveItem(contextIdentifier, event) {
         const eventId = ensureValidEntityId(event?.id, "event.id");
         const sanitizedEvent = sanitizeInstantValue(event);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/events",
-  "version": "1.22.83-beta.development.0",
+  "version": "1.22.85-beta.development.0",
   "description": "Ekairos Events - Context-first workflow runtime",
   "type": "module",
   "main": "dist/index.js",
@@ -127,7 +127,7 @@
   },
   "dependencies": {
     "@ai-sdk/openai": "^2.0.52",
-    "@ekairos/domain": "^1.22.83-beta.development.0",
+    "@ekairos/domain": "^1.22.85-beta.development.0",
     "@instantdb/admin": "0.22.158",
     "@instantdb/core": "0.22.142",
     "@vercel/mcp-adapter": "^1.0.0",