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

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

@@ -1,21 +1,78 @@
-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) {
+    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.
  *
  * This matches DurableAgent's internal `toolsToModelTools` behavior:
  * `inputSchema: asSchema(tool.inputSchema).jsonSchema`
  */
-export function toolsToModelTools(tools) {
+export function actionsToActionSpecs(tools) {
     const out = {};
     for (const [name, tool] of Object.entries(tools)) {
-        const inputSchema = tool?.inputSchema;
+        if (isProviderDefinedTool(tool)) {
+            out[name] = {
+                type: "provider-defined",
+                id: tool.id,
+                name: tool.name,
+                args: tool.args,
+            };
+            continue;
+        }
+        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] = {
-            description: tool?.description,
-            inputSchema: asSchema(inputSchema).jsonSchema,
+            type: "function",
+            description: typeof record.description === "string" ? record.description : undefined,
+            inputSchema: toJsonSchema(inputSchema),
+            outputSchema: outputSchema ? toJsonSchema(outputSchema) : undefined,
+            providerOptions: record.providerOptions,
         };
     }
     return out;
 }
+export function actionSpecToAiSdkTool(name, spec, wrapJsonSchema) {
+    if (spec.type === "provider-defined") {
+        return {
+            type: "provider-defined",
+            id: spec.id,
+            name: spec.name ?? name,
+            args: spec.args ?? {},
+        };
+    }
+    return {
+        type: "function",
+        description: spec.description,
+        inputSchema: wrapJsonSchema(spec.inputSchema),
+        outputSchema: spec.outputSchema ? wrapJsonSchema(spec.outputSchema) : undefined,
+        providerOptions: spec.providerOptions,
+    };
+}
+/**
+ * @deprecated Use actionsToActionSpecs.
+ */
+export const toolsToModelTools = actionsToActionSpecs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/events",
-  "version": "1.22.34-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,7 +116,9 @@
     "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",
     "test:ai-sdk-reactor": "vitest run -c vitest.config.mts src/tests/context.ai-sdk-reactor.instant.test.ts",
     "test:ai-sdk-reactor:real": "vitest run -c vitest.config.mts src/tests/context.ai-sdk-reactor.real.instant.test.ts",
@@ -116,7 +127,7 @@
   },
   "dependencies": {
     "@ai-sdk/openai": "^2.0.52",
-    "@ekairos/domain": "^1.22.34-beta.development.0",
+    "@ekairos/domain": "^1.22.35",
     "@instantdb/admin": "0.22.158",
     "@instantdb/core": "0.22.142",
     "@vercel/mcp-adapter": "^1.0.0",
@@ -125,18 +136,21 @@
     "ajv": "^8.17.1",
     "jose": "^6.1.3",
     "llamaindex": "^0.12.0",
+    "partial-json": "^0.1.7",
     "react": "^19.2.0",
-    "workflow": "4.1.0-beta.55",
+    "workflow": "5.0.0-beta.5",
     "xmlbuilder2": "^3.1.1",
-    "zod": "^4.1.8"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@ekairos/testing": "workspace:*",
     "@ekairos/tsconfig": "workspace:*",
     "@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")));
-}