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

package/dist/steps/store.steps.js

@@ -1,6 +1,12 @@
+import { getContextRuntimeServices } from "../context.runtime.js";
 import { OUTPUT_ITEM_TYPE, WEB_CHANNEL } from "../context.events.js";
 import { writeContextTraceEvents } from "./trace.steps.js";
 import { getClientResumeHookUrl, toolApprovalHookToken, toolApprovalWebhookToken, } from "../context.hooks.js";
+async function getRuntimeAndEnv(params) {
+    const env = params.runtime.env;
+    const runtime = await getContextRuntimeServices(params.runtime);
+    return { runtime, env };
+}
 async function maybeWriteTraceEvents(env, traceEvents) {
     if (!traceEvents?.length)
         return;
@@ -92,24 +98,23 @@ function logStepDebug(message, payload) {
  *
  * This is the "context init" boundary for the story engine.
  */
-export async function initializeContext(env, contextIdentifier, opts) {
+export async function initializeContext(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(env);
+    const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
     // Detect creation explicitly so the engine can run onContextCreated hooks.
     let result;
-    if (!contextIdentifier) {
+    if (!params.contextIdentifier) {
         const context = await store.getOrCreateContext(null);
         result = { context, isNew: true };
     }
     else {
-        const existing = await store.getContext(contextIdentifier);
+        const existing = await store.getContext(params.contextIdentifier);
         if (existing) {
             result = { context: existing, isNew: false };
         }
         else {
-            const created = await store.getOrCreateContext(contextIdentifier);
+            const created = await store.getOrCreateContext(params.contextIdentifier);
             result = { context: created, isNew: true };
         }
     }
@@ -132,29 +137,29 @@ export async function initializeContext(env, contextIdentifier, opts) {
     }
     return result;
 }
-export async function updateContextContent(env, contextIdentifier, content) {
+export async function updateContextContent(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(env);
-    return await store.updateContextContent(contextIdentifier, content);
+    const { runtime } = await getRuntimeAndEnv(params);
+    return await runtime.store.updateContextContent(params.contextIdentifier, params.content);
 }
-export async function updateContextStatus(env, contextIdentifier, status) {
+export async function updateContextReactor(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(env);
-    await store.updateContextStatus(contextIdentifier, status);
+    const { runtime } = await getRuntimeAndEnv(params);
+    return await runtime.store.updateContextReactor(params.contextIdentifier, params.reactor);
 }
-export async function saveTriggerItem(env, contextIdentifier, event) {
+export async function updateContextStatus(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(env);
-    const saved = await store.saveItem(contextIdentifier, event);
-    return saved;
+    const { runtime } = await getRuntimeAndEnv(params);
+    await runtime.store.updateContextStatus(params.contextIdentifier, params.status);
+}
+export async function saveTriggerItem(params) {
+    "use step";
+    const { runtime } = await getRuntimeAndEnv(params);
+    return await runtime.store.saveItem(params.contextIdentifier, params.event);
 }
 export async function saveTriggerAndCreateExecution(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(params.env);
+    const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
     logStepDebug("saveTriggerAndCreateExecution:start", {
         contextIdentifier: summarizeContextIdentifierForLog(params.contextIdentifier),
@@ -241,7 +246,7 @@ export async function saveTriggerAndCreateExecution(params) {
         throw error;
     }
     const { runId, meta } = await resolveWorkflowRunId({
-        env: params.env,
+        env,
         db,
         executionId: execution.id,
     });
@@ -329,7 +334,7 @@ export async function saveTriggerAndCreateExecution(params) {
                 },
             },
         ];
-        await maybeWriteTraceEvents(params.env, events);
+        await maybeWriteTraceEvents(env, events);
     }
     return {
         triggerEvent: saved,
@@ -340,26 +345,25 @@ export async function saveTriggerAndCreateExecution(params) {
         },
     };
 }
-export async function saveReactionItem(env, contextIdentifier, event, opts) {
+export async function saveReactionItem(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(env);
+    const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
-    const saved = await store.saveItem(contextIdentifier, event);
-    if (opts?.executionId) {
+    const saved = await store.saveItem(params.contextIdentifier, params.event);
+    if (params.opts?.executionId) {
         await store.linkItemToExecution({
             itemId: saved.id,
-            executionId: opts.executionId,
+            executionId: params.opts.executionId,
         });
     }
-    const contextId = opts?.contextId ??
-        (typeof contextIdentifier?.id === "string"
-            ? String(contextIdentifier.id)
+    const contextId = params.opts?.contextId ??
+        (typeof params.contextIdentifier?.id === "string"
+            ? String(params.contextIdentifier.id)
             : undefined);
     const { runId, meta } = await resolveWorkflowRunId({
         env,
         db,
-        executionId: opts?.executionId,
+        executionId: params.opts?.executionId,
     });
     if (runId) {
         const events = [
@@ -369,7 +373,7 @@ export async function saveReactionItem(env, contextIdentifier, event, opts) {
                 eventKind: "context.item",
                 eventAt: new Date().toISOString(),
                 contextId,
-                executionId: opts?.executionId,
+                executionId: params.opts?.executionId,
                 contextEventId: String(saved.id),
                 payload: {
                     ...saved,
@@ -377,30 +381,30 @@ export async function saveReactionItem(env, contextIdentifier, event, opts) {
                 },
             },
         ];
-        if (opts?.executionId && opts.reviewRequests?.length) {
+        if (params.opts?.executionId && params.opts.reviewRequests?.length) {
             const resumeHookUrl = getClientResumeHookUrl();
             const workflowUrl = meta && typeof meta.url === "string" && meta.url.trim()
                 ? String(meta.url)
                 : undefined;
-            for (const rr of opts.reviewRequests) {
+            for (const rr of params.opts.reviewRequests) {
                 const toolCallId = String(rr.toolCallId);
                 events.push({
                     workflowRunId: runId,
-                    eventId: `context_review:${String(opts.executionId)}:${toolCallId}`,
+                    eventId: `context_review:${String(params.opts.executionId)}:${toolCallId}`,
                     eventKind: "context.review",
                     eventAt: new Date().toISOString(),
                     contextId,
-                    executionId: String(opts.executionId),
+                    executionId: String(params.opts.executionId),
                     toolCallId,
                     payload: {
                         status: "in_review",
                         toolName: rr.toolName ?? "",
                         hookToken: toolApprovalHookToken({
-                            executionId: String(opts.executionId),
+                            executionId: String(params.opts.executionId),
                             toolCallId,
                         }),
                         webhookToken: toolApprovalWebhookToken({
-                            executionId: String(opts.executionId),
+                            executionId: String(params.opts.executionId),
                             toolCallId,
                         }),
                         resumeHookUrl,
@@ -413,16 +417,15 @@ export async function saveReactionItem(env, contextIdentifier, event, opts) {
     }
     return saved;
 }
-export async function updateItem(env, eventId, event, opts) {
+export async function updateItem(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(env);
+    const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
-    const saved = await store.updateItem(eventId, event);
+    const saved = await store.updateItem(params.eventId, params.event);
     const { runId } = await resolveWorkflowRunId({
         env,
         db,
-        executionId: opts?.executionId,
+        executionId: params.opts?.executionId,
     });
     if (runId) {
         await maybeWriteTraceEvents(env, [
@@ -431,8 +434,8 @@ export async function updateItem(env, eventId, event, opts) {
                 eventId: `context_item:${String(saved.id)}`,
                 eventKind: "context.item",
                 eventAt: new Date().toISOString(),
-                contextId: opts?.contextId,
-                executionId: opts?.executionId,
+                contextId: params.opts?.contextId,
+                executionId: params.opts?.executionId,
                 contextEventId: String(saved.id),
                 payload: {
                     ...saved,
@@ -443,16 +446,15 @@ export async function updateItem(env, eventId, event, opts) {
     }
     return saved;
 }
-export async function createExecution(env, contextIdentifier, triggerEventId, reactionEventId) {
+export async function createExecution(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(env);
-    return await store.createExecution(contextIdentifier, triggerEventId, reactionEventId);
+    const { runtime } = await getRuntimeAndEnv(params);
+    return await runtime.store.createExecution(params.contextIdentifier, params.triggerEventId, params.reactionEventId);
 }
 export async function createReactionItem(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(params.env);
+    const { runtime } = await getRuntimeAndEnv(params);
+    const { store } = runtime;
     // Generate a new reaction event id inside the step boundary.
     const uuid = globalThis.crypto?.randomUUID?.();
     const reactionEventId = typeof uuid === "string"
@@ -461,31 +463,30 @@ export async function createReactionItem(params) {
     const execution = await store.createExecution(params.contextIdentifier, params.triggerEventId, reactionEventId);
     return { reactionEventId, executionId: execution.id };
 }
-export async function completeExecution(env, contextIdentifier, executionId, status) {
+export async function completeExecution(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(env);
+    const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
-    await store.completeExecution(contextIdentifier, executionId, status);
-    const contextId = typeof contextIdentifier?.id === "string"
-        ? String(contextIdentifier.id)
+    await store.completeExecution(params.contextIdentifier, params.executionId, params.status);
+    const contextId = typeof params.contextIdentifier?.id === "string"
+        ? String(params.contextIdentifier.id)
         : undefined;
     const { runId } = await resolveWorkflowRunId({
         env,
         db,
-        executionId,
+        executionId: params.executionId,
     });
     if (runId) {
         await maybeWriteTraceEvents(env, [
             {
                 workflowRunId: runId,
-                eventId: `context_execution:${String(executionId)}:${status}`,
+                eventId: `context_execution:${String(params.executionId)}:${params.status}`,
                 eventKind: "context.execution",
                 eventAt: new Date().toISOString(),
                 contextId,
-                executionId: String(executionId),
+                executionId: String(params.executionId),
                 payload: {
-                    status,
+                    status: params.status,
                 },
             },
         ]);
@@ -493,9 +494,8 @@ export async function completeExecution(env, contextIdentifier, executionId, sta
 }
 export async function updateExecutionWorkflowRun(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(params.env);
-    const db = runtime?.db;
+    const { runtime } = await getRuntimeAndEnv(params);
+    const db = runtime.db;
     if (db) {
         await db.transact([
             db.tx.event_executions[params.executionId].update({
@@ -507,8 +507,8 @@ export async function updateExecutionWorkflowRun(params) {
 }
 export async function createContextStep(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(params.env);
+    const { runtime } = await getRuntimeAndEnv(params);
+    const { store } = runtime;
     const res = await store.createStep({
         executionId: params.executionId,
         iteration: params.iteration,
@@ -517,20 +517,19 @@ export async function createContextStep(params) {
 }
 export async function updateContextStep(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(params.env);
+    const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
     await store.updateStep(params.stepId, {
         ...params.patch,
         updatedAt: new Date(),
     });
     const { runId } = await resolveWorkflowRunId({
-        env: params.env,
+        env,
         db,
         executionId: params.executionId,
     });
     if (runId) {
-        await maybeWriteTraceEvents(params.env, [
+        await maybeWriteTraceEvents(env, [
             {
                 workflowRunId: runId,
                 eventId: `context_step:${String(params.stepId)}`,
@@ -558,18 +557,17 @@ export async function updateContextStep(params) {
 }
 export async function linkItemToExecutionStep(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const { store } = await getContextRuntime(params.env);
+    const { runtime } = await getRuntimeAndEnv(params);
+    const { store } = runtime;
     await store.linkItemToExecution({ itemId: params.itemId, executionId: params.executionId });
 }
 export async function saveContextPartsStep(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(params.env);
+    const { runtime, env } = await getRuntimeAndEnv(params);
     const { store, db } = runtime;
     await store.saveStepParts({ stepId: params.stepId, parts: params.parts });
     const { runId } = await resolveWorkflowRunId({
-        env: params.env,
+        env,
         db,
         executionId: params.executionId,
     });
@@ -590,6 +588,6 @@ export async function saveContextPartsStep(params) {
                 payload: part,
             });
         }
-        await maybeWriteTraceEvents(params.env, events);
+        await maybeWriteTraceEvents(env, events);
     }
 }

package/dist/steps/stream.steps.d.ts

@@ -1,5 +1,6 @@
 import type { UIMessageChunk } from "ai";
 import type { ContextEnvironment } from "../context.config.js";
+import type { ContextRuntime } from "../context.runtime.js";
 import { type ContextStepStreamChunk } from "../context.step-stream.js";
 import type { ContextStreamEvent } from "../context.stream.js";
 export declare function writeContextEvents(params: {
@@ -20,17 +21,17 @@ export type PersistedContextStepStreamSession = {
     stepId: string;
 };
 export declare function createPersistedContextStepStream(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     executionId: string;
     stepId: string;
     clientId?: string;
 }): Promise<PersistedContextStepStreamSession>;
 export declare function closePersistedContextStepStream(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     session: PersistedContextStepStreamSession;
 }): Promise<void>;
 export declare function abortPersistedContextStepStream(params: {
-    env: ContextEnvironment;
+    runtime: ContextRuntime<ContextEnvironment>;
     session: PersistedContextStepStreamSession;
     reason?: string | null;
 }): Promise<void>;

package/dist/steps/stream.steps.js

@@ -1,3 +1,4 @@
+import { getContextRuntimeServices } from "../context.runtime.js";
 import { contextStreamByteLength, parseContextStepStreamChunk, } from "../context.step-stream.js";
 export async function writeContextEvents(params) {
     "use step";
@@ -14,7 +15,9 @@ export async function writeContextEvents(params) {
         }
     }
     finally {
-        writer.releaseLock();
+        if (typeof writer?.releaseLock === "function") {
+            writer.releaseLock();
+        }
     }
 }
 export async function closeContextStream(params) {
@@ -30,7 +33,9 @@ export async function closeContextStream(params) {
             await writer.write({ type: "finish" });
         }
         finally {
-            writer.releaseLock();
+            if (typeof writer?.releaseLock === "function") {
+                writer.releaseLock();
+            }
         }
     }
     if (!preventClose) {
@@ -60,8 +65,7 @@ export function createContextStepStreamClientId(stepId) {
 }
 export async function createPersistedContextStepStream(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(params.env);
+    const runtime = await getContextRuntimeServices(params.runtime);
     const db = runtime?.db;
     if (!db?.streams?.createWriteStream) {
         throw new Error("InstantDB streams are not available on the configured runtime. Upgrade @instantdb/admin to a streams-capable version.");
@@ -103,8 +107,7 @@ export async function createPersistedContextStepStream(params) {
 }
 async function finalizePersistedContextStepStream(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(params.env);
+    const runtime = await getContextRuntimeServices(params.runtime);
     const db = runtime?.db;
     const writer = params.session.stream.getWriter();
     try {
@@ -116,7 +119,9 @@ async function finalizePersistedContextStepStream(params) {
         }
     }
     finally {
-        writer.releaseLock();
+        if (typeof writer?.releaseLock === "function") {
+            writer.releaseLock();
+        }
     }
     const now = new Date();
     const txs = [
@@ -140,14 +145,14 @@ async function finalizePersistedContextStepStream(params) {
 }
 export async function closePersistedContextStepStream(params) {
     return await finalizePersistedContextStepStream({
-        env: params.env,
+        runtime: params.runtime,
         session: params.session,
         mode: "close",
     });
 }
 export async function abortPersistedContextStepStream(params) {
     return await finalizePersistedContextStepStream({
-        env: params.env,
+        runtime: params.runtime,
         session: params.session,
         mode: "abort",
         abortReason: params.reason,

package/dist/steps/trace.steps.d.ts

@@ -1,5 +1,6 @@
 import "../polyfills/dom-events.js";
 import type { ContextEnvironment } from "../context.config.js";
+import type { ContextRuntime } from "../context.runtime.js";
 import type { TraceEventKind } from "../context.contract.js";
 export type ContextTraceEventWrite = {
     workflowRunId: string;
@@ -33,6 +34,7 @@ export type ContextTraceEventWrite = {
     testId?: string;
 };
 export declare function writeContextTraceEvents(params: {
+    runtime?: ContextRuntime<ContextEnvironment>;
     env: ContextEnvironment;
     events: ContextTraceEventWrite[];
 }): Promise<void>;

package/dist/steps/trace.steps.js

@@ -1,4 +1,5 @@
 import "../polyfills/dom-events.js";
+import { getContextRuntimeServices } from "../context.runtime.js";
 import { lookup } from "@instantdb/admin";
 function requireBaseUrl() {
     const baseUrl = process.env.EKAIROS_CORE_BASE_URL ||
@@ -84,8 +85,10 @@ export async function writeContextTraceEvents(params) {
     const strict = envTrace?.strict === true || process.env.EKAIROS_TRACES_STRICT === "1";
     // 1) Local trace persistence (InstantDB source of truth).
     try {
-        const { getContextRuntime } = await import("../runtime.js");
-        const runtime = await getContextRuntime(params.env);
+        if (!params.runtime) {
+            throw new Error("[context/trace] runtime is required");
+        }
+        const runtime = await getContextRuntimeServices(params.runtime);
         const db = runtime?.db;
         if (db) {
             const now = new Date();

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

@@ -14,6 +14,10 @@ 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>>;
+    updateContextReactor<C>(contextIdentifier: ContextIdentifier, reactor: {
+        kind: string;
+        state?: Record<string, unknown> | null;
+    }): Promise<StoredContext<C>>;
     updateContextStatus(contextIdentifier: ContextIdentifier, status: ContextStatus): Promise<void>;
     private resolveContext;
     saveItem(contextIdentifier: ContextIdentifier, event: ContextItem): Promise<ContextItem>;

package/dist/stores/instant.store.js

@@ -118,6 +118,9 @@ export class InstantStore {
                     ? new Date(row.updatedAt)
                     : undefined,
             content: row?.content ?? null,
+            reactor: row?.reactor && typeof row.reactor === "object"
+                ? row.reactor
+                : null,
         };
     }
     async ensureContextKey(context, expectedKey) {
@@ -144,6 +147,7 @@ export class InstantStore {
                 key,
                 status: "open_idle",
                 content: {},
+                reactor: undefined,
             }),
         ]);
         const context = await this.getContext({ id: contextId });
@@ -203,6 +207,21 @@ export class InstantStore {
             throw new Error("InstantStore: context not found after update");
         return updated;
     }
+    async updateContextReactor(contextIdentifier, reactor) {
+        const context = await this.getContext(contextIdentifier);
+        if (!context?.id)
+            throw new Error("InstantStore: context not found");
+        await this.db.transact([
+            this.db.tx.event_contexts[context.id].update({
+                reactor: reactor,
+                updatedAt: new Date(),
+            }),
+        ]);
+        const updated = await this.getContext({ id: context.id });
+        if (!updated)
+            throw new Error("InstantStore: context not found after reactor update");
+        return updated;
+    }
     async updateContextStatus(contextIdentifier, status) {
         const context = await this.getContext(contextIdentifier);
         if (!context?.id)

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

@@ -6,14 +6,48 @@ import { type Tool } from "ai";
  * - Keep Zod/function values out of step arguments
  * - Convert tool input schemas to plain JSON Schema in workflow context
  */
-export type SerializableToolForModel = {
+export type SerializableFunctionActionSpec = {
+    type?: "function";
     description?: string;
     inputSchema: unknown;
+    providerOptions?: unknown;
 };
+export type SerializableProviderDefinedActionSpec = {
+    type: "provider-defined";
+    id: string;
+    name?: string;
+    args?: Record<string, unknown>;
+};
+export type SerializableActionSpec = SerializableFunctionActionSpec | SerializableProviderDefinedActionSpec;
+/**
+ * @deprecated Use SerializableActionSpec.
+ */
+export type SerializableToolForModel = SerializableActionSpec;
 /**
  * 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 declare function toolsToModelTools(tools: Record<string, Tool>): Record<string, SerializableToolForModel>;
+export declare function actionsToActionSpecs(tools: Record<string, Tool>): Record<string, SerializableActionSpec>;
+export declare function actionSpecToAiSdkTool(name: string, spec: SerializableActionSpec, wrapJsonSchema: (schema: unknown) => unknown): {
+    type: "provider-defined";
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+    description?: undefined;
+    inputSchema?: undefined;
+    providerOptions?: undefined;
+} | {
+    type: "function";
+    description: string | undefined;
+    inputSchema: unknown;
+    providerOptions: unknown;
+    id?: undefined;
+    name?: undefined;
+    args?: undefined;
+};
+/**
+ * @deprecated Use actionsToActionSpecs.
+ */
+export declare const toolsToModelTools: typeof actionsToActionSpecs;

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

@@ -1,21 +1,59 @@
 import { asSchema } from "ai";
+function isProviderDefinedTool(tool) {
+    return (Boolean(tool) &&
+        typeof tool === "object" &&
+        tool.type === "provider-defined" &&
+        typeof tool.id === "string" &&
+        tool.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)) {
+        if (isProviderDefinedTool(tool)) {
+            out[name] = {
+                type: "provider-defined",
+                id: tool.id,
+                name: tool.name,
+                args: tool.args,
+            };
+            continue;
+        }
         const inputSchema = tool?.inputSchema;
         if (!inputSchema) {
             throw new Error(`Context: tool "${name}" is missing inputSchema (required for model tool calls)`);
         }
         out[name] = {
+            type: "function",
             description: tool?.description,
             inputSchema: asSchema(inputSchema).jsonSchema,
+            providerOptions: tool?.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),
+        providerOptions: spec.providerOptions,
+    };
+}
+/**
+ * @deprecated Use actionsToActionSpecs.
+ */
+export const toolsToModelTools = actionsToActionSpecs;