@ekairos/events 1.22.35-beta.development.0 → 1.22.35

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

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

package/dist/stores/instant.store.js

@@ -71,6 +71,43 @@ function ensureValidEntityId(value, label) {
     }
     return normalized;
 }
+function sanitizeInstantString(value) {
+    return value.includes("\u0000") ? value.replace(/\u0000/g, "") : value;
+}
+function isOpaqueJsonValue(value) {
+    return (value instanceof Date ||
+        value instanceof ArrayBuffer ||
+        ArrayBuffer.isView(value));
+}
+function sanitizeInstantValue(value, seen = new WeakMap()) {
+    if (typeof value === "string") {
+        return sanitizeInstantString(value);
+    }
+    if (value === null || value === undefined || typeof value !== "object") {
+        return value;
+    }
+    if (isOpaqueJsonValue(value)) {
+        return value;
+    }
+    const cached = seen.get(value);
+    if (cached) {
+        return cached;
+    }
+    if (Array.isArray(value)) {
+        const out = [];
+        seen.set(value, out);
+        for (const item of value) {
+            out.push(sanitizeInstantValue(item, seen));
+        }
+        return out;
+    }
+    const out = {};
+    seen.set(value, out);
+    for (const [key, entryValue] of Object.entries(value)) {
+        out[sanitizeInstantString(key)] = sanitizeInstantValue(entryValue, seen);
+    }
+    return out;
+}
 function logInstantTransactFailure(params) {
     if (!shouldDebugInstantStore())
         return;
@@ -118,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,
@@ -147,6 +187,9 @@ export class InstantStore {
                 key,
                 status: "open_idle",
                 content: {},
+                description: undefined,
+                goal: undefined,
+                resources: [],
                 reactor: undefined,
             }),
         ]);
@@ -207,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)
@@ -242,8 +307,69 @@ 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);
         const context = await this.resolveContext(contextIdentifier);
         const existing = await this.getItem(eventId);
         if (existing?.status && existing.status !== "stored") {
@@ -251,7 +377,7 @@ export class InstantStore {
         }
         const txs = [
             this.db.tx.event_items[eventId].update({
-                ...event,
+                ...sanitizedEvent,
                 id: eventId,
                 status: "stored",
             }),
@@ -277,7 +403,7 @@ export class InstantStore {
             throw error;
         }
         return {
-            ...event,
+            ...sanitizedEvent,
             id: eventId,
             status: "stored",
         };
@@ -287,10 +413,11 @@ export class InstantStore {
         if (current?.status && event.status && current.status !== event.status) {
             assertItemTransition(current.status, event.status);
         }
-        await this.db.transact([this.db.tx.event_items[eventId].update(event)]);
+        const sanitizedEvent = sanitizeInstantValue(event);
+        await this.db.transact([this.db.tx.event_items[eventId].update(sanitizedEvent)]);
         return {
             ...current,
-            ...event,
+            ...sanitizedEvent,
             id: eventId,
         };
     }
@@ -517,9 +644,12 @@ export class InstantStore {
             }
         }
         const update = {
-            ...patch,
             updatedAt: patch.updatedAt ?? new Date(),
         };
+        if (patch.status !== undefined)
+            update.status = patch.status;
+        if (patch.errorText !== undefined)
+            update.errorText = patch.errorText;
         await this.db.transact([this.db.tx.event_steps[stepId].update(update)]);
     }
     async linkItemToExecution(params) {
@@ -528,7 +658,7 @@ export class InstantStore {
         ]);
     }
     async saveStepParts(params) {
-        const parts = normalizePartsForPersistence(Array.isArray(params.parts) ? params.parts : []);
+        const parts = sanitizeInstantValue(normalizePartsForPersistence(Array.isArray(params.parts) ? params.parts : []));
         if (parts.length === 0)
             return;
         const txs = parts.map((part, idx) => {

package/dist/tools-to-model-tools.d.ts

@@ -1,4 +1,3 @@
-import { type Tool } from "ai";
 /**
  * Serializable "tool" shape to pass across the Workflow step boundary.
  *
@@ -10,6 +9,7 @@ export type SerializableFunctionActionSpec = {
     type?: "function";
     description?: string;
     inputSchema: unknown;
+    outputSchema?: unknown;
     providerOptions?: unknown;
 };
 export type SerializableProviderDefinedActionSpec = {
@@ -29,7 +29,7 @@ export type SerializableToolForModel = SerializableActionSpec;
  * This matches DurableAgent's internal `toolsToModelTools` behavior:
  * `inputSchema: asSchema(tool.inputSchema).jsonSchema`
  */
-export declare function actionsToActionSpecs(tools: Record<string, Tool>): Record<string, SerializableActionSpec>;
+export declare function actionsToActionSpecs(tools: Record<string, unknown>): Record<string, SerializableActionSpec>;
 export declare function actionSpecToAiSdkTool(name: string, spec: SerializableActionSpec, wrapJsonSchema: (schema: unknown) => unknown): {
     type: "provider-defined";
     id: string;
@@ -37,11 +37,13 @@ export declare function actionSpecToAiSdkTool(name: string, spec: SerializableAc
     args: Record<string, unknown>;
     description?: undefined;
     inputSchema?: undefined;
+    outputSchema?: undefined;
     providerOptions?: undefined;
 } | {
     type: "function";
     description: string | undefined;
     inputSchema: unknown;
+    outputSchema: unknown;
     providerOptions: unknown;
     id?: undefined;
     name?: undefined;

package/dist/tools-to-model-tools.js

@@ -1,10 +1,25 @@
-import { asSchema } from "ai";
+import { z } from "zod";
+function toJsonSchema(schema) {
+    if (!schema)
+        return schema;
+    const jsonSchema = schema?.jsonSchema;
+    if (jsonSchema)
+        return jsonSchema;
+    try {
+        return z.toJSONSchema(schema);
+    }
+    catch {
+        return schema;
+    }
+}
+function asRecord(value) {
+    return value && typeof value === "object" ? value : {};
+}
 function isProviderDefinedTool(tool) {
-    return (Boolean(tool) &&
-        typeof tool === "object" &&
-        tool.type === "provider-defined" &&
-        typeof tool.id === "string" &&
-        tool.id.trim().length > 0);
+    const record = asRecord(tool);
+    return (record.type === "provider-defined" &&
+        typeof record.id === "string" &&
+        record.id.trim().length > 0);
 }
 /**
  * Convert AI SDK tools to a serializable representation that can be passed to `"use-step"` functions.
@@ -24,15 +39,18 @@ export function actionsToActionSpecs(tools) {
             };
             continue;
         }
-        const inputSchema = tool?.inputSchema;
+        const record = asRecord(tool);
+        const inputSchema = record.inputSchema ?? record.input;
         if (!inputSchema) {
-            throw new Error(`Context: tool "${name}" is missing inputSchema (required for model tool calls)`);
+            throw new Error(`Context: action "${name}" is missing input/inputSchema (required for model action calls)`);
         }
+        const outputSchema = record.outputSchema ?? record.output;
         out[name] = {
             type: "function",
-            description: tool?.description,
-            inputSchema: asSchema(inputSchema).jsonSchema,
-            providerOptions: tool?.providerOptions,
+            description: typeof record.description === "string" ? record.description : undefined,
+            inputSchema: toJsonSchema(inputSchema),
+            outputSchema: outputSchema ? toJsonSchema(outputSchema) : undefined,
+            providerOptions: record.providerOptions,
         };
     }
     return out;
@@ -50,6 +68,7 @@ export function actionSpecToAiSdkTool(name, spec, wrapJsonSchema) {
         type: "function",
         description: spec.description,
         inputSchema: wrapJsonSchema(spec.inputSchema),
+        outputSchema: spec.outputSchema ? wrapJsonSchema(spec.outputSchema) : undefined,
         providerOptions: spec.providerOptions,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/events",
-  "version": "1.22.35-beta.development.0",
+  "version": "1.22.35",
   "description": "Ekairos Events - Context-first workflow runtime",
   "type": "module",
   "main": "dist/index.js",
@@ -30,6 +30,12 @@
       "require": "./dist/schema.js",
       "default": "./dist/schema.js"
     },
+    "./domain": {
+      "types": "./dist/domain.d.ts",
+      "import": "./dist/domain.js",
+      "require": "./dist/domain.js",
+      "default": "./dist/domain.js"
+    },
     "./runtime": {
       "types": "./dist/runtime.d.ts",
       "import": "./dist/runtime.js",
@@ -78,6 +84,9 @@
       "schema": [
         "dist/schema.d.ts"
       ],
+      "domain": [
+        "dist/domain.d.ts"
+      ],
       "runtime": [
         "dist/runtime.d.ts"
       ],
@@ -107,6 +116,7 @@
     "watch": "tsc -p tsconfig.json --watch",
     "clean": "node -e \"require('fs').rmSync('dist', {recursive:true, force:true})\"",
     "typecheck": "tsc --noEmit",
+    "typecheck:tests": "tsc --noEmit -p tsconfig.typecheck.json",
     "test": "vitest run -c vitest.config.mts",
     "test:workflow": "vitest run -c vitest.workflow.config.mts",
     "pretest:ai-sdk-reactor": "pnpm --filter @ekairos/domain build",
@@ -117,7 +127,7 @@
   },
   "dependencies": {
     "@ai-sdk/openai": "^2.0.52",
-    "@ekairos/domain": "^1.22.35-beta.development.0",
+    "@ekairos/domain": "^1.22.35",
     "@instantdb/admin": "0.22.158",
     "@instantdb/core": "0.22.142",
     "@vercel/mcp-adapter": "^1.0.0",
@@ -126,20 +136,21 @@
     "ajv": "^8.17.1",
     "jose": "^6.1.3",
     "llamaindex": "^0.12.0",
+    "partial-json": "^0.1.7",
     "react": "^19.2.0",
-    "workflow": "5.0.0-beta.1",
+    "workflow": "5.0.0-beta.5",
     "xmlbuilder2": "^3.1.1",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@ekairos/testing": "workspace:*",
     "@ekairos/tsconfig": "workspace:*",
-    "@workflow/serde": "5.0.0-beta.0",
-    "@workflow/vitest": "5.0.0-beta.1",
     "@types/node": "^24.5.0",
     "@types/react": "^19.2.2",
+    "@workflow/serde": "5.0.0-beta.1",
+    "@workflow/vitest": "5.0.0-beta.5",
     "dotenv": "^17.2.3",
-    "vitest": "^3.2.4",
-    "typescript": "^5.9.2"
+    "typescript": "^5.9.2",
+    "vitest": "^4.0.8"
   }
 }

package/dist/context.toolcalls.d.ts

@@ -1,60 +0,0 @@
-/**
- * ## context.toolcalls.ts
- *
- * This module isolates the **tool-call plumbing** used by `context.engine.ts`.
- *
- * In our runtime, tool calls are represented as **event parts** produced by the AI SDK.
- * The engine needs to:
- * - extract a normalized list of tool calls from `event.content.parts`, and
- * - merge tool execution outcomes back into those parts (so the persisted event reflects
- *   `output-available` / `output-error`, etc.).
- *
- * Keeping this logic here helps `context.engine.ts` read like orchestration, and keeps
- * these transformations testable and reusable.
- */
-import type { ContextItem } from "./context.store.js";
-export type ToolCall = {
-    toolCallId: string;
-    toolName: string;
-    args: any;
-};
-/**
- * Extracts tool calls from an event's `parts` array.
- *
- * Expected part shape (loosely):
- * - `type`: string like `"tool-<toolName>"`
- * - `toolCallId`: string
- * - `input`: any (tool args)
- *
- * We intentionally treat the input as `any` because the part schema is produced by the AI SDK.
- */
-export declare function extractToolCallsFromParts(parts: any[] | undefined | null): ToolCall[];
-/**
- * Applies a tool execution outcome to the matching tool part.
- *
- * This does not mutate `parts` — it returns a new array.
- *
- * We match the tool part by:
- * - `type === "tool-<toolName>"` and
- * - `toolCallId` equality
- *
- * Then we set:
- * - on success: `{ state: "output-available", output: <result> }`
- * - on failure: `{ state: "output-error", errorText: <message> }`
- */
-export declare function applyToolExecutionResultToParts(parts: any[], toolCall: Pick<ToolCall, "toolCallId" | "toolName">, execution: {
-    success: boolean;
-    result: any;
-    message?: string;
-}): any[];
-/**
- * Returns `true` when a given tool has a **settled** execution result in an event's parts.
- *
- * We treat a tool part as "executed" once it has either:
- * - `state: "output-available"` (success), or
- * - `state: "output-error"` (failure).
- *
- * This is useful for stop/continue logic in `context.shouldContinue(...)` where you want to
- * decide based on the persisted `reactionEvent` (not ephemeral in-memory arrays).
- */
-export declare function didToolExecute(event: Pick<ContextItem, "content">, toolName: string): boolean;

package/dist/context.toolcalls.js

@@ -1,117 +0,0 @@
-/**
- * ## context.toolcalls.ts
- *
- * This module isolates the **tool-call plumbing** used by `context.engine.ts`.
- *
- * In our runtime, tool calls are represented as **event parts** produced by the AI SDK.
- * The engine needs to:
- * - extract a normalized list of tool calls from `event.content.parts`, and
- * - merge tool execution outcomes back into those parts (so the persisted event reflects
- *   `output-available` / `output-error`, etc.).
- *
- * Keeping this logic here helps `context.engine.ts` read like orchestration, and keeps
- * these transformations testable and reusable.
- */
-import { isContextPartEnvelope, normalizePartsForPersistence, normalizeToolResultContentToBlocks, } from "./context.parts.js";
-/**
- * Extracts tool calls from an event's `parts` array.
- *
- * Expected part shape (loosely):
- * - `type`: string like `"tool-<toolName>"`
- * - `toolCallId`: string
- * - `input`: any (tool args)
- *
- * We intentionally treat the input as `any` because the part schema is produced by the AI SDK.
- */
-export function extractToolCallsFromParts(parts) {
-    const safeParts = parts ?? [];
-    return safeParts.reduce((acc, p) => {
-        if (isContextPartEnvelope(p) && p.type === "tool-call") {
-            const firstContent = Array.isArray(p.content) ? p.content[0] : undefined;
-            const args = firstContent && firstContent.type === "json" ? firstContent.value : p.content;
-            acc.push({
-                toolCallId: p.toolCallId,
-                toolName: p.toolName,
-                args,
-            });
-            return acc;
-        }
-        if (typeof p?.type === "string" && p.type.startsWith("tool-")) {
-            const toolName = p.type.split("-").slice(1).join("-");
-            acc.push({ toolCallId: p.toolCallId, toolName, args: p.input });
-        }
-        return acc;
-    }, []);
-}
-/**
- * Applies a tool execution outcome to the matching tool part.
- *
- * This does not mutate `parts` — it returns a new array.
- *
- * We match the tool part by:
- * - `type === "tool-<toolName>"` and
- * - `toolCallId` equality
- *
- * Then we set:
- * - on success: `{ state: "output-available", output: <result> }`
- * - on failure: `{ state: "output-error", errorText: <message> }`
- */
-export function applyToolExecutionResultToParts(parts, toolCall, execution) {
-    const normalized = normalizePartsForPersistence(parts);
-    const next = [];
-    let insertedResult = false;
-    const resultContent = execution.success
-        ? normalizeToolResultContentToBlocks(execution.result)
-        : [
-            {
-                type: "text",
-                text: String(execution.message || "Error"),
-            },
-        ];
-    for (const part of normalized) {
-        next.push(part);
-        if (part.type !== "tool-call") {
-            continue;
-        }
-        if (part.toolCallId !== toolCall.toolCallId ||
-            part.toolName !== toolCall.toolName) {
-            continue;
-        }
-        next.push({
-            type: "tool-result",
-            toolCallId: toolCall.toolCallId,
-            toolName: toolCall.toolName,
-            state: execution.success ? "output-available" : "output-error",
-            content: resultContent,
-        });
-        insertedResult = true;
-    }
-    if (!insertedResult) {
-        next.push({
-            type: "tool-result",
-            toolCallId: toolCall.toolCallId,
-            toolName: toolCall.toolName,
-            state: execution.success ? "output-available" : "output-error",
-            content: resultContent,
-        });
-    }
-    return next;
-}
-/**
- * Returns `true` when a given tool has a **settled** execution result in an event's parts.
- *
- * We treat a tool part as "executed" once it has either:
- * - `state: "output-available"` (success), or
- * - `state: "output-error"` (failure).
- *
- * This is useful for stop/continue logic in `context.shouldContinue(...)` where you want to
- * decide based on the persisted `reactionEvent` (not ephemeral in-memory arrays).
- */
-export function didToolExecute(event, toolName) {
-    const parts = (event.content.parts ?? []).flatMap((part) => isContextPartEnvelope(part) ? [part] : normalizePartsForPersistence([part]));
-    return parts.some((p) => (p.type === "tool-result" &&
-        p.toolName === toolName &&
-        (p.state === "output-available" || p.state === "output-error")) ||
-        (p.type === `tool-${toolName}` &&
-            (p.state === "output-available" || p.state === "output-error")));
-}