@ekairos/events 1.22.4-beta.development.0

package/dist/env.js

@@ -0,0 +1,53 @@
+const envByRunIdSymbol = Symbol.for("ekairos.context.envByRunId");
+const defaultEnvSymbol = Symbol.for("ekairos.context.defaultEnv");
+function getEnvMap() {
+    if (typeof globalThis === "undefined")
+        return new Map();
+    const existing = globalThis[envByRunIdSymbol];
+    if (existing)
+        return existing;
+    const created = new Map();
+    globalThis[envByRunIdSymbol] = created;
+    return created;
+}
+function setDefaultEnv(env) {
+    if (typeof globalThis === "undefined")
+        return;
+    globalThis[defaultEnvSymbol] = env ?? null;
+}
+function getDefaultEnv() {
+    if (typeof globalThis === "undefined")
+        return null;
+    return globalThis[defaultEnvSymbol] ?? null;
+}
+export function registerContextEnv(env, runId) {
+    if (runId) {
+        getEnvMap().set(String(runId), env);
+        return;
+    }
+    setDefaultEnv(env);
+}
+async function tryGetWorkflowRunId() {
+    try {
+        const mod = await import("workflow");
+        const meta = mod?.getWorkflowMetadata?.();
+        const runId = meta?.workflowRunId;
+        return runId ? String(runId) : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function getContextEnv() {
+    const runId = await tryGetWorkflowRunId();
+    if (runId) {
+        const stored = getEnvMap().get(runId);
+        if (stored)
+            return stored;
+    }
+    const fallback = getDefaultEnv();
+    if (fallback)
+        return fallback;
+    throw new Error("@ekairos/events: env is not configured for this workflow run. " +
+        "Call registerContextEnv(env) at workflow start or ensure the context runtime registers env.");
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { context, createContext, createAiSdkReactor, createScriptedReactor, type CreateAiSdkReactorOptions, type CreateScriptedReactorOptions, type ScriptedReactorStep, type ContextConfig, type ContextInstance, type ContextOptions, type ContextStreamOptions, type ContextReactor, type ContextReactorParams, type ContextReactionResult, type ContextActionRequest, type ContextReactionLLM, ContextEngine, type RegistrableContextBuilder, type ContextReactParams, type ContextReactResult, type ContextDurableWorkflowPayload, type ContextDurableWorkflowFunction, type ContextModelInit, type ContextTool, runContextReactionDirect, } from "./context.js";
+export type { ContextStore, ContextIdentifier, StoredContext, ContextItem, ContextExecution, } from "./context.store.js";
+export type { WireDate, ContextMirrorContext, ContextMirrorExecution, ContextMirrorWrite, ContextMirrorRequest, } from "./mirror.js";
+export { registerContext, getContext, getContextFactory, hasContext, listContexts, type ContextKey, } from "./context.registry.js";
+export { eventsDomain } from "./schema.js";
+export { didToolExecute, extractToolCallsFromParts } from "./context.toolcalls.js";
+export { contextPartSchema, contextPartEnvelopeSchema, contextPartContentSchema, isContextPartEnvelope, parseContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
+export type { ContextPart, ContextPartEnvelope, ContextPartContent, } from "./context.parts.js";
+export { INPUT_ITEM_TYPE, INPUT_TEXT_ITEM_TYPE, OUTPUT_ITEM_TYPE, WEB_CHANNEL, AGENT_CHANNEL, EMAIL_CHANNEL, createUserItemFromUIMessages, createAssistantItemFromUIMessages, convertToUIMessage, convertItemToModelMessages, convertItemsToModelMessages, convertModelMessageToItem, isContextOutputPart, normalizeContextOutputPart, type ResponseMessage, type ContextOutputPart, type ContextOutputContentPart, } from "./context.events.js";
+export { CONTEXT_STATUSES, EXECUTION_STATUSES, STEP_STATUSES, STEP_KINDS, ITEM_STATUSES, ITEM_TYPES, CHANNELS, TRACE_EVENT_KINDS, CONTEXT_STREAM_CHUNK_TYPES, STREAM_LIFECYCLE_CHUNK_TYPES, STREAM_TEXT_CHUNK_TYPES, STREAM_REASONING_CHUNK_TYPES, STREAM_ACTION_CHUNK_TYPES, STREAM_SOURCE_CHUNK_TYPES, STREAM_METADATA_CHUNK_TYPES, STREAM_ERROR_CHUNK_TYPES, CONTEXT_TRANSITIONS, EXECUTION_TRANSITIONS, STEP_TRANSITIONS, ITEM_TRANSITIONS, canContextTransition, canExecutionTransition, canStepTransition, canItemTransition, assertContextTransition, assertExecutionTransition, assertStepTransition, assertItemTransition, isContextStreamChunkType, assertContextPartKey, } from "./context.contract.js";
+export type { Transition, ContextStatus, ExecutionStatus, StepStatus, StepKind, ItemStatus, ItemType, Channel, TraceEventKind, ContextStreamChunkType, ContextTransition, ExecutionTransition, StepTransition, ItemTransition, } from "./context.contract.js";
+export { DEFAULT_CODEX_TOOL_NAME, DEFAULT_CODEX_MODEL, codexToolInputSchema, buildDefaultCodexNarrative, didCodexToolExecute, createCodexContextBuilder, type CodexContextRuntimeMode, type CodexContextReasoningLevel, type CodexContextRuntime, type CodexContextEnv, type CodexToolInput, type CodexToolOutput, type CodexExecuteArgs, type CodexContextBuilderConfig, type CodexContextBuilder, } from "./codex.js";
+export { useContext, type ContextSnapshot, type ContextStreamChunk, type UseContextOptions, } from "./react.js";
+export { parseContextStreamEvent, assertContextStreamTransitions, validateContextStreamTimeline, } from "./context.stream.js";
+export { CONTEXT_STEP_STREAM_VERSION, createContextStepStreamChunk, parseContextStepStreamChunk, encodeContextStepStreamChunk, } from "./context.step-stream.js";
+export type { ContextStreamEvent, ContextCreatedEvent, ContextResolvedEvent, ContextStatusChangedEvent, ContextContentUpdatedEvent, ExecutionCreatedEvent, ExecutionCompletedEvent, ExecutionFailedEvent, ItemCreatedEvent, ItemUpdatedEvent, ItemPendingEvent, ItemCompletedEvent, StepCreatedEvent, StepUpdatedEvent, StepCompletedEvent, StepFailedEvent, PartCreatedEvent, PartUpdatedEvent, ChunkEmittedEvent, } from "./context.stream.js";
+export type { ContextStepStreamChunk } from "./context.step-stream.js";
+export type { ContextSkillPackage, ContextSkillPackageFile } from "./context.skill.js";

package/dist/index.js

@@ -0,0 +1,11 @@
+export { context, createContext, createAiSdkReactor, createScriptedReactor, ContextEngine, runContextReactionDirect, } from "./context.js";
+export { registerContext, getContext, getContextFactory, hasContext, listContexts, } from "./context.registry.js";
+export { eventsDomain } from "./schema.js";
+export { didToolExecute, extractToolCallsFromParts } from "./context.toolcalls.js";
+export { contextPartSchema, contextPartEnvelopeSchema, contextPartContentSchema, isContextPartEnvelope, parseContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
+export { INPUT_ITEM_TYPE, INPUT_TEXT_ITEM_TYPE, OUTPUT_ITEM_TYPE, WEB_CHANNEL, AGENT_CHANNEL, EMAIL_CHANNEL, createUserItemFromUIMessages, createAssistantItemFromUIMessages, convertToUIMessage, convertItemToModelMessages, convertItemsToModelMessages, convertModelMessageToItem, isContextOutputPart, normalizeContextOutputPart, } from "./context.events.js";
+export { CONTEXT_STATUSES, EXECUTION_STATUSES, STEP_STATUSES, STEP_KINDS, ITEM_STATUSES, ITEM_TYPES, CHANNELS, TRACE_EVENT_KINDS, CONTEXT_STREAM_CHUNK_TYPES, STREAM_LIFECYCLE_CHUNK_TYPES, STREAM_TEXT_CHUNK_TYPES, STREAM_REASONING_CHUNK_TYPES, STREAM_ACTION_CHUNK_TYPES, STREAM_SOURCE_CHUNK_TYPES, STREAM_METADATA_CHUNK_TYPES, STREAM_ERROR_CHUNK_TYPES, CONTEXT_TRANSITIONS, EXECUTION_TRANSITIONS, STEP_TRANSITIONS, ITEM_TRANSITIONS, canContextTransition, canExecutionTransition, canStepTransition, canItemTransition, assertContextTransition, assertExecutionTransition, assertStepTransition, assertItemTransition, isContextStreamChunkType, assertContextPartKey, } from "./context.contract.js";
+export { DEFAULT_CODEX_TOOL_NAME, DEFAULT_CODEX_MODEL, codexToolInputSchema, buildDefaultCodexNarrative, didCodexToolExecute, createCodexContextBuilder, } from "./codex.js";
+export { useContext, } from "./react.js";
+export { parseContextStreamEvent, assertContextStreamTransitions, validateContextStreamTimeline, } from "./context.stream.js";
+export { CONTEXT_STEP_STREAM_VERSION, createContextStepStreamChunk, parseContextStepStreamChunk, encodeContextStepStreamChunk, } from "./context.step-stream.js";

package/dist/mcp.d.ts

@@ -0,0 +1 @@
+export { createMcpHandler, withMcpAuth } from "@vercel/mcp-adapter";

package/dist/mcp.js

@@ -0,0 +1 @@
+export { createMcpHandler, withMcpAuth } from "@vercel/mcp-adapter";

package/dist/mirror.d.ts

@@ -0,0 +1,41 @@
+import type { ContextItem, StoredContext } from "./context.store.js";
+/**
+ * Wire-safe (JSON) mirror types shared by:
+ * - the workflow sender (`@ekairos/events` steps)
+ * - the ekairos-core receiver (`/api/context`)
+ *
+ * Note: `StoredContext` contains Date objects, but over HTTP we send ISO strings.
+ */
+export type WireDate = string;
+export type ContextMirrorContext = Omit<StoredContext<unknown>, "createdAt" | "updatedAt"> & {
+    createdAt: WireDate;
+    updatedAt?: WireDate;
+};
+export type ContextMirrorExecution = Record<string, unknown> & {
+    createdAt?: WireDate;
+    updatedAt?: WireDate;
+};
+export type ContextMirrorWrite = {
+    type: "context.upsert";
+    context: ContextMirrorContext;
+} | {
+    type: "event.upsert";
+    contextId: string;
+    event: ContextItem;
+} | {
+    type: "event.update";
+    eventId: string;
+    event: ContextItem;
+} | {
+    type: "execution.upsert";
+    contextId: string;
+    executionId: string;
+    execution: ContextMirrorExecution;
+    triggerEventId: string;
+    reactionEventId: string;
+    setCurrentExecution?: boolean;
+};
+export type ContextMirrorRequest = {
+    orgId: string;
+    writes: ContextMirrorWrite[];
+};

package/dist/mirror.js

@@ -0,0 +1 @@
+export {};

package/dist/oidc.d.ts

@@ -0,0 +1,7 @@
+type VerifyOidcOptions = {
+    jwksUrl?: string;
+    issuer?: string;
+    audience?: string | string[];
+};
+export declare function verifyOidcToken(token: string, options?: VerifyOidcOptions): Promise<boolean>;
+export {};

package/dist/oidc.js

@@ -0,0 +1,25 @@
+import { createRemoteJWKSet, jwtVerify } from "jose";
+const jwksCache = new Map();
+function getJwks(jwksUrl) {
+    const cached = jwksCache.get(jwksUrl);
+    if (cached)
+        return cached;
+    const jwks = createRemoteJWKSet(new URL(jwksUrl));
+    jwksCache.set(jwksUrl, jwks);
+    return jwks;
+}
+export async function verifyOidcToken(token, options = {}) {
+    if (!token)
+        return false;
+    const jwksUrl = String(options.jwksUrl ?? "").trim();
+    if (!jwksUrl) {
+        throw new Error("Missing jwksUrl for OIDC verification");
+    }
+    const verifyOptions = {};
+    if (options.issuer)
+        verifyOptions.issuer = options.issuer;
+    if (options.audience)
+        verifyOptions.audience = options.audience;
+    await jwtVerify(token, getJwks(jwksUrl), verifyOptions);
+    return true;
+}

package/dist/polyfills/dom-events.d.ts

@@ -0,0 +1 @@
+export declare function ensureDomEvents(): void;

package/dist/polyfills/dom-events.js

@@ -0,0 +1,89 @@
+function ensureEvent() {
+    if (typeof globalThis.Event !== "undefined")
+        return;
+    class NodeEvent {
+        constructor(type, init) {
+            this.defaultPrevented = false;
+            this.cancelable = false;
+            this.timeStamp = Date.now();
+            this.type = type;
+            if (init && typeof init === "object") {
+                Object.assign(this, init);
+            }
+        }
+        preventDefault() {
+            this.defaultPrevented = true;
+        }
+    }
+    globalThis.Event = NodeEvent;
+}
+function ensureEventTarget() {
+    if (typeof globalThis.EventTarget !== "undefined")
+        return;
+    class NodeEventTarget {
+        constructor() {
+            this.listeners = new Map();
+        }
+        addEventListener(type, listener) {
+            if (!listener)
+                return;
+            const bucket = this.listeners.get(type) ?? new Set();
+            bucket.add(listener);
+            this.listeners.set(type, bucket);
+        }
+        removeEventListener(type, listener) {
+            if (!listener)
+                return;
+            const bucket = this.listeners.get(type);
+            if (!bucket)
+                return;
+            bucket.delete(listener);
+            if (bucket.size === 0)
+                this.listeners.delete(type);
+        }
+        dispatchEvent(event) {
+            const bucket = this.listeners.get(event?.type);
+            if (bucket) {
+                for (const listener of [...bucket]) {
+                    try {
+                        listener.call(this, event);
+                    }
+                    catch {
+                        // ignore listener errors
+                    }
+                }
+            }
+            const handler = this[`on${event?.type}`];
+            if (typeof handler === "function") {
+                try {
+                    handler.call(this, event);
+                }
+                catch {
+                    // ignore handler errors
+                }
+            }
+            return !event?.defaultPrevented;
+        }
+    }
+    globalThis.EventTarget = NodeEventTarget;
+}
+function ensureMessageEvent() {
+    if (typeof globalThis.MessageEvent !== "undefined")
+        return;
+    const BaseEvent = globalThis.Event;
+    class NodeMessageEvent extends BaseEvent {
+        constructor(type, init) {
+            super(type, init);
+            this.data = init?.data;
+            this.origin = typeof init?.origin === "string" ? init.origin : "";
+            this.lastEventId = typeof init?.lastEventId === "string" ? init.lastEventId : "";
+        }
+    }
+    globalThis.MessageEvent = NodeMessageEvent;
+}
+export function ensureDomEvents() {
+    ensureEvent();
+    ensureEventTarget();
+    ensureMessageEvent();
+}
+ensureDomEvents();

package/dist/react.d.ts

@@ -0,0 +1,42 @@
+import type { ContextStatus } from "./context.contract.js";
+export type ContextSnapshot<Context = unknown, Item = Record<string, unknown>> = {
+    context: {
+        id: string;
+        key: string | null;
+        name?: string | null;
+        status: ContextStatus;
+        content: Context;
+        createdAt: string | null;
+        updatedAt: string | null;
+    } | null;
+    items: Item[];
+};
+export type ContextStreamChunk = {
+    type: `data-context.${string}`;
+    data?: {
+        contextId?: string;
+    };
+} | {
+    type: string;
+    [key: string]: unknown;
+};
+export type UseContextOptions<Context = unknown, Item = Record<string, unknown>> = {
+    contextKey: string;
+    orgId?: string;
+    endpoint?: string;
+    refreshMs?: number;
+    ensure?: boolean;
+    enabled?: boolean;
+    initialData?: ContextSnapshot<Context, Item> | null;
+    fetchImpl?: typeof fetch;
+};
+export declare function useContext<Context = unknown, Item = Record<string, unknown>>(options: UseContextOptions<Context, Item>): {
+    data: ContextSnapshot<Context, Item> | null;
+    isLoading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+    setData: import("react").Dispatch<import("react").SetStateAction<ContextSnapshot<Context, Item> | null>>;
+    contextId: string | null;
+    applyChunk: (chunk: ContextStreamChunk) => void;
+    url: string;
+};

package/dist/react.js

@@ -0,0 +1,88 @@
+"use client";
+import { useCallback, useEffect, useMemo, useState } from "react";
+function toErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error ?? "unknown_error");
+}
+function buildContextUrl(options) {
+    const base = String(options.endpoint || "/api/context").replace(/\/+$/, "");
+    const key = encodeURIComponent(options.contextKey);
+    const params = new URLSearchParams();
+    if (options.orgId)
+        params.set("orgId", options.orgId);
+    if (options.ensure)
+        params.set("ensure", "1");
+    const query = params.toString();
+    return query.length > 0 ? `${base}/${key}?${query}` : `${base}/${key}`;
+}
+export function useContext(options) {
+    const [data, setData] = useState(options.initialData ?? null);
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const [contextId, setContextId] = useState(null);
+    const enabled = options.enabled ?? true;
+    const url = useMemo(() => {
+        if (!enabled || !options.contextKey)
+            return "";
+        return buildContextUrl(options);
+    }, [enabled, options.endpoint, options.orgId, options.contextKey, options.ensure]);
+    const refresh = useCallback(async () => {
+        if (!enabled || !options.contextKey)
+            return;
+        setIsLoading(true);
+        setError(null);
+        const fetchImpl = options.fetchImpl ?? fetch;
+        try {
+            const response = await fetchImpl(url, { cache: "no-store" });
+            if (!response.ok) {
+                const body = await response.text();
+                throw new Error(body || `context_fetch_failed:${response.status}`);
+            }
+            const snapshot = (await response.json());
+            setData(snapshot);
+            setContextId(snapshot.context?.id ?? null);
+        }
+        catch (err) {
+            setError(toErrorMessage(err));
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [enabled, options.fetchImpl, options.contextKey, url]);
+    const applyChunk = useCallback((chunk) => {
+        if (!chunk || typeof chunk !== "object")
+            return;
+        if (typeof chunk.type === "string" && chunk.type.startsWith("data-context.")) {
+            const payload = "data" in chunk && chunk.data && typeof chunk.data === "object"
+                ? chunk.data
+                : undefined;
+            const candidate = typeof payload?.contextId === "string"
+                ? payload.contextId
+                : null;
+            if (candidate)
+                setContextId(candidate);
+        }
+    }, []);
+    useEffect(() => {
+        void refresh();
+    }, [refresh]);
+    useEffect(() => {
+        if (!enabled || !options.refreshMs || options.refreshMs <= 0)
+            return;
+        const intervalId = setInterval(() => {
+            void refresh();
+        }, options.refreshMs);
+        return () => clearInterval(intervalId);
+    }, [enabled, options.refreshMs, refresh]);
+    return {
+        data,
+        isLoading,
+        error,
+        refresh,
+        setData,
+        contextId,
+        applyChunk,
+        url,
+    };
+}

package/dist/reactors/ai-sdk.chunk-map.d.ts

@@ -0,0 +1,12 @@
+import type { UIMessageChunk } from "ai";
+import type { ChunkEmittedEvent } from "../context.stream.js";
+export type MapAiSdkChunkToContextEventParams = {
+    chunk: UIMessageChunk | Record<string, unknown>;
+    contextId: string;
+    executionId?: string;
+    stepId?: string;
+    itemId?: string;
+    provider?: string;
+    sequence: number;
+};
+export declare function mapAiSdkChunkToContextEvent(params: MapAiSdkChunkToContextEventParams): ChunkEmittedEvent;

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

@@ -0,0 +1,143 @@
+const REDACT_KEY = /token|authorization|cookie|secret|api[_-]?key|password/i;
+function asRecord(value) {
+    if (!value || typeof value !== "object")
+        return {};
+    return value;
+}
+function readString(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function toJsonSafe(value) {
+    if (typeof value === "undefined")
+        return undefined;
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return undefined;
+    }
+}
+function sanitizeRaw(value) {
+    const seen = new WeakSet();
+    try {
+        return JSON.parse(JSON.stringify(value, (key, currentValue) => {
+            if (REDACT_KEY.test(key))
+                return "[redacted]";
+            if (typeof currentValue === "string" && currentValue.length > 20000) {
+                return "[truncated-string]";
+            }
+            if (currentValue && typeof currentValue === "object") {
+                if (seen.has(currentValue))
+                    return "[circular]";
+                seen.add(currentValue);
+            }
+            return currentValue;
+        }));
+    }
+    catch {
+        return undefined;
+    }
+}
+function mapAiSdkChunkType(providerChunkType) {
+    switch (providerChunkType) {
+        case "start":
+        case "stream-start":
+            return "chunk.start";
+        case "start-step":
+            return "chunk.start_step";
+        case "finish-step":
+            return "chunk.finish_step";
+        case "finish":
+            return "chunk.finish";
+        case "text-start":
+            return "chunk.text_start";
+        case "text-delta":
+            return "chunk.text_delta";
+        case "text-end":
+            return "chunk.text_end";
+        case "reasoning-start":
+            return "chunk.reasoning_start";
+        case "reasoning-delta":
+            return "chunk.reasoning_delta";
+        case "reasoning-end":
+            return "chunk.reasoning_end";
+        case "tool-input-start":
+        case "tool-call-start":
+            return "chunk.action_input_start";
+        case "tool-input-delta":
+        case "tool-call-delta":
+            return "chunk.action_input_delta";
+        case "tool-input-available":
+        case "tool-input-end":
+        case "tool-call":
+        case "tool-call-end":
+            return "chunk.action_input_available";
+        case "tool-output-available":
+            return "chunk.action_output_available";
+        case "tool-output-error":
+            return "chunk.action_output_error";
+        case "source-url":
+            return "chunk.source_url";
+        case "source-document":
+            return "chunk.source_document";
+        case "file":
+            return "chunk.file";
+        case "message-metadata":
+            return "chunk.message_metadata";
+        case "response-metadata":
+            return "chunk.response_metadata";
+        case "error":
+            return "chunk.error";
+        default:
+            return "chunk.unknown";
+    }
+}
+function buildNormalizedData(chunk) {
+    const normalized = {};
+    const fields = [
+        "id",
+        "text",
+        "delta",
+        "state",
+        "toolName",
+        "toolCallId",
+        "finishReason",
+        "url",
+        "title",
+        "name",
+        "mimeType",
+    ];
+    for (const field of fields) {
+        const value = chunk[field];
+        if (typeof value !== "undefined") {
+            normalized[field] = value;
+        }
+    }
+    if (Object.keys(normalized).length === 0) {
+        return {};
+    }
+    return toJsonSafe(normalized) ?? {};
+}
+export function mapAiSdkChunkToContextEvent(params) {
+    const chunk = asRecord(params.chunk);
+    const providerChunkType = readString(chunk, "type") ?? "unknown";
+    const chunkType = mapAiSdkChunkType(providerChunkType);
+    const actionRef = readString(chunk, "toolCallId") ??
+        readString(chunk, "id");
+    return {
+        type: "chunk.emitted",
+        at: new Date().toISOString(),
+        chunkType,
+        contextId: params.contextId,
+        executionId: params.executionId,
+        stepId: params.stepId,
+        itemId: params.itemId,
+        actionRef: chunkType.startsWith("chunk.action_") ? actionRef : undefined,
+        provider: params.provider,
+        providerChunkType,
+        sequence: params.sequence,
+        data: buildNormalizedData(chunk),
+        raw: sanitizeRaw(chunk),
+    };
+}

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

@@ -0,0 +1,33 @@
+import type { ContextEnvironment } from "../context.config.js";
+import type { ContextModelInit } from "../context.engine.js";
+import type { ContextIdentifier, StoredContext, ContextItem } from "../context.store.js";
+import type { ContextReactor } from "./types.js";
+export type CreateAiSdkReactorOptions<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, Config = unknown> = {
+    resolveConfig?: (params: {
+        env: Env;
+        context: StoredContext<Context>;
+        contextIdentifier: ContextIdentifier;
+        triggerEvent: ContextItem;
+        model: ContextModelInit;
+        eventId: string;
+        executionId: string;
+        contextId: string;
+        stepId: string;
+        iteration: number;
+    }) => Promise<Config> | Config;
+    selectModel?: (params: {
+        env: Env;
+        context: StoredContext<Context>;
+        triggerEvent: ContextItem;
+        baseModel: ContextModelInit;
+        config: Config;
+    }) => Promise<ContextModelInit> | ContextModelInit;
+    selectMaxModelSteps?: (params: {
+        env: Env;
+        context: StoredContext<Context>;
+        triggerEvent: ContextItem;
+        baseMaxModelSteps: number;
+        config: Config;
+    }) => Promise<number> | number;
+};
+export declare function createAiSdkReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, Config = unknown>(options?: CreateAiSdkReactorOptions<Context, Env, Config>): ContextReactor<Context, Env>;

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

@@ -0,0 +1,65 @@
+import { executeAiSdkReaction } from "./ai-sdk.step.js";
+export function createAiSdkReactor(options) {
+    return async (params) => {
+        let config;
+        if (options?.resolveConfig) {
+            config = await options.resolveConfig({
+                env: params.env,
+                context: params.context,
+                contextIdentifier: params.contextIdentifier,
+                triggerEvent: params.triggerEvent,
+                model: params.model,
+                eventId: params.eventId,
+                executionId: params.executionId,
+                contextId: params.contextId,
+                stepId: params.stepId,
+                iteration: params.iteration,
+            });
+        }
+        const model = options?.selectModel && config !== undefined
+            ? await options.selectModel({
+                env: params.env,
+                context: params.context,
+                triggerEvent: params.triggerEvent,
+                baseModel: params.model,
+                config,
+            })
+            : params.model;
+        const maxSteps = options?.selectMaxModelSteps && config !== undefined
+            ? await options.selectMaxModelSteps({
+                env: params.env,
+                context: params.context,
+                triggerEvent: params.triggerEvent,
+                baseMaxModelSteps: params.maxModelSteps,
+                config,
+            })
+            : params.maxModelSteps;
+        const result = await executeAiSdkReaction({
+            env: params.env,
+            contextIdentifier: params.contextIdentifier,
+            model,
+            system: params.systemPrompt,
+            tools: params.toolsForModel,
+            eventId: params.eventId,
+            iteration: params.iteration,
+            maxSteps,
+            sendStart: params.sendStart,
+            silent: params.silent,
+            contextStepStream: params.contextStepStream,
+            writable: params.writable,
+            executionId: params.executionId,
+            contextId: params.contextId,
+            stepId: params.stepId,
+        });
+        return {
+            assistantEvent: result.assistantEvent,
+            actionRequests: result.toolCalls.map((entry) => ({
+                actionRef: String(entry.toolCallId),
+                actionName: String(entry.toolName),
+                input: entry.args,
+            })),
+            messagesForModel: result.messagesForModel,
+            llm: result.llm,
+        };
+    };
+}