@undefineds.co/xpod 0.2.44 → 0.3.0

package/dist/api/runs/InngestRunExecutionBackend.d.ts

@@ -0,0 +1,416 @@
+import { Inngest } from 'inngest';
+import type { EventPayload } from 'inngest/types';
+import type { StoreContext } from '../chatkit/store';
+import type { AgentRuntimeEvent } from './AgentRuntimeTypes';
+import { ManagedRunWorker, type ManagedRunStore } from './ManagedRunWorker';
+import type { RunExecutionBackend, RunExecutionInput } from './RunExecutionBackend';
+export declare const XPOD_RUN_REQUESTED_EVENT = "xpod/run.requested";
+export declare const XPOD_RUN_CONTINUE_REQUESTED_EVENT = "xpod/run.continue_requested";
+export declare const XPOD_AGENT_RUN_FUNCTION_ID = "xpod-agent-run";
+export interface XpodRunRequestedEventData {
+    runId: string;
+    threadId: string;
+    executionKey?: string;
+    authBindingId?: string;
+    webId?: string;
+    continuation?: RunExecutionInput['continuation'];
+}
+export type XpodRunRequestedEvent = EventPayload<XpodRunRequestedEventData> & {
+    name: typeof XPOD_RUN_REQUESTED_EVENT | typeof XPOD_RUN_CONTINUE_REQUESTED_EVENT;
+};
+export interface InngestRunExecutionBackendOptions {
+    client?: Inngest;
+    baseUrl?: string;
+    eventKey?: string;
+    signingKey?: string;
+    runtimeDriver?: RunExecutionBackend;
+    store?: ManagedRunStore<StoreContext>;
+    managedRunWorker?: ManagedRunWorker<StoreContext>;
+    contextResolver?: (data: XpodRunRequestedEventData) => StoreContext | Promise<StoreContext | undefined> | undefined;
+    contextRecorder?: (context: StoreContext | undefined) => void;
+    durableDelivery?: boolean;
+    /**
+     * When true, execute the registered Inngest handler in-process after sending
+     * the event. This keeps Chat streaming low-latency while preserving the
+     * Inngest event/function boundary for the managed-agents backend.
+     */
+    executeInline?: boolean;
+}
+/**
+ * Inngest-backed managed-agent execution backend.
+ *
+ * Xpod owns the Run facts; Inngest owns durable function delivery. In this
+ * first API-facing implementation the function can execute inline so ChatKit
+ * still receives a normal SSE stream without waiting for external polling.
+ *
+ * The in-memory pending map is only the streaming bridge for an active HTTP
+ * request. When no pending stream exists, the registered Inngest function can
+ * restore the Run from store through ManagedRunWorker.
+ */
+export declare class InngestRunExecutionBackend implements RunExecutionBackend {
+    private readonly client;
+    private readonly runtimeDriver;
+    private readonly managedRunWorker?;
+    private readonly contextResolver?;
+    private readonly contextRecorder?;
+    private readonly executeInline;
+    private readonly durableDelivery;
+    private readonly pendingRuns;
+    readonly agentRunFunction: import("inngest").InngestFunction<import("inngest").InngestFunction.Options<[{
+        readonly event: "xpod/run.requested";
+    }, {
+        readonly event: "xpod/run.continue_requested";
+    }], import("inngest").HandlerWithTriggers<{
+        sendEvent: (idOrOptions: import("inngest").StepOptionsOrId, payload: import("inngest").SendEventPayload) => Promise<import("inngest/types").SendEventOutput<import("inngest").ClientOptionsFromInngest<Inngest<import("inngest").ClientOptions>>>>;
+        waitForSignal: <TData>(idOrOptions: import("inngest").StepOptionsOrId, opts: {
+            signal: string;
+            timeout: number | string | Date | import("inngest").DurationLike | import("inngest").InstantLike | import("inngest").ZonedDateTimeLike;
+            onConflict: "replace" | "fail";
+        }) => Promise<{
+            signal: string;
+            data: import("inngest/types").Jsonify<TData>;
+        } | null>;
+        realtime: {
+            publish: <TData>(idOrOptions: import("inngest").StepOptionsOrId, topicRef: import("inngest").Realtime.TopicRef<TData>, data: TData) => Promise<TData>;
+        };
+        sendSignal: (idOrOptions: import("inngest").StepOptionsOrId, opts: {
+            signal: string;
+            data?: unknown;
+        }) => Promise<import("inngest/api/api").InngestApi.SendSignalResponse>;
+        waitForEvent: <TOpts extends {
+            event: string | import("inngest").EventType<string, any>;
+            timeout: number | string | Date | import("inngest").DurationLike | import("inngest").InstantLike | import("inngest").ZonedDateTimeLike;
+        } & import("inngest").ExclusiveKeys<{
+            match?: string;
+            if?: string;
+        }, "match", "if">>(idOrOptions: import("inngest").StepOptionsOrId, opts: TOpts) => Promise<TOpts extends {
+            event: import("inngest").EventType<infer TName extends string, import("inngest").StandardSchemaV1<infer TData extends Record<string, unknown>>>;
+        } ? {
+            name: TName;
+            data: TData;
+            id: string;
+            ts: number;
+            v?: string;
+        } | null : TOpts extends {
+            event: import("inngest").EventType<infer TName_1 extends string, undefined>;
+        } ? {
+            name: TName_1;
+            data: Record<string, any>;
+            id: string;
+            ts: number;
+            v?: string;
+        } | null : TOpts extends {
+            event: infer TName_2 extends string;
+            schema: import("inngest").StandardSchemaV1<infer TData_1 extends Record<string, unknown>>;
+        } ? {
+            name: TName_2;
+            data: TData_1;
+            id: string;
+            ts: number;
+            v?: string;
+        } | null : TOpts extends {
+            event: infer TName_3 extends string;
+        } ? {
+            name: TName_3;
+            data: Record<string, any>;
+            id: string;
+            ts: number;
+            v?: string;
+        } | null : EventPayload<any> | null>;
+        run: <TFn extends (...args: any[]) => unknown>(idOrOptions: import("inngest").StepOptionsOrId, fn: TFn, ...input: Parameters<TFn>) => Promise<import("inngest/types").Jsonify<TFn extends (...args: Parameters<TFn>) => Promise<infer U> ? Awaited<U extends void ? null : U> : ReturnType<TFn> extends void ? null : ReturnType<TFn>>>;
+        ai: {
+            infer: <TAdapter extends import("inngest").AiAdapter>(idOrOptions: import("inngest").StepOptionsOrId, options: {
+                model: TAdapter;
+                body: import("inngest").AiAdapter.Input<TAdapter>;
+            }) => Promise<import("inngest").AiAdapter.Output<TAdapter>>;
+            wrap: <TFn extends (...args: any[]) => unknown>(idOrOptions: import("inngest").StepOptionsOrId, fn: TFn, ...input: Parameters<TFn>) => Promise<import("inngest/types").Jsonify<TFn extends (...args: Parameters<TFn>) => Promise<infer U> ? Awaited<U extends void ? null : U> : ReturnType<TFn> extends void ? null : ReturnType<TFn>>>;
+            models: {
+                anthropic: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").Anthropic.AiModelOptions], import("inngest").Anthropic.AiModel>;
+                gemini: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").Gemini.AiModelOptions], import("inngest").Gemini.AiModel>;
+                openai: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").OpenAi.AiModelOptions], import("inngest").OpenAi.AiModel>;
+                deepseek: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").DeepSeek.AiModelOptions], import("inngest").DeepSeek.AiModel>;
+                grok: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").Grok.AiModelOptions], import("inngest").Grok.AiModel>;
+            };
+        };
+        sleep: (idOrOptions: import("inngest").StepOptionsOrId, time: number | string | import("inngest").DurationLike) => Promise<void>;
+        sleepUntil: (idOrOptions: import("inngest").StepOptionsOrId, time: Date | string | import("inngest").InstantLike | import("inngest").ZonedDateTimeLike) => Promise<void>;
+        invoke: <TFunction extends import("inngest/types").InvokeTargetFunctionDefinition>(idOrOptions: import("inngest").StepOptionsOrId, opts: {
+            function: TFunction;
+        } & Omit<import("inngest/types").TriggerEventFromFunction<TFunction>, "id"> & {
+            timeout?: number | string | Date | import("inngest").DurationLike | import("inngest").InstantLike | import("inngest").ZonedDateTimeLike;
+        }) => import("inngest/types").InvocationResult<import("inngest/types").Jsonify<import("inngest").GetFunctionOutputRaw<TFunction>>>;
+        fetch: import("inngest").StepFetch;
+    }, [{
+        readonly event: "xpod/run.requested";
+    }, {
+        readonly event: "xpod/run.continue_requested";
+    }], Omit<Omit<import("inngest").BaseContext<Inngest.Any>, never> & Record<never, never> & {
+        logger: import("inngest").Logger;
+    }, "group" | "requestId" | "runId" | "event" | "defer" | "events" | "jobId" | "step" | "attempt" | "maxAttempts"> & import("inngest").FailureEventArgs<EventPayload<any>> & {
+        step: {
+            sendEvent: (idOrOptions: import("inngest").StepOptionsOrId, payload: import("inngest").SendEventPayload) => Promise<import("inngest/types").SendEventOutput<import("inngest").ClientOptionsFromInngest<Inngest<import("inngest").ClientOptions>>>>;
+            waitForSignal: <TData>(idOrOptions: import("inngest").StepOptionsOrId, opts: {
+                signal: string;
+                timeout: number | string | Date | import("inngest").DurationLike | import("inngest").InstantLike | import("inngest").ZonedDateTimeLike;
+                onConflict: "replace" | "fail";
+            }) => Promise<{
+                signal: string;
+                data: import("inngest/types").Jsonify<TData>;
+            } | null>;
+            realtime: {
+                publish: <TData>(idOrOptions: import("inngest").StepOptionsOrId, topicRef: import("inngest").Realtime.TopicRef<TData>, data: TData) => Promise<TData>;
+            };
+            sendSignal: (idOrOptions: import("inngest").StepOptionsOrId, opts: {
+                signal: string;
+                data?: unknown;
+            }) => Promise<import("inngest/api/api").InngestApi.SendSignalResponse>;
+            waitForEvent: <TOpts extends {
+                event: string | import("inngest").EventType<string, any>;
+                timeout: number | string | Date | import("inngest").DurationLike | import("inngest").InstantLike | import("inngest").ZonedDateTimeLike;
+            } & import("inngest").ExclusiveKeys<{
+                match?: string;
+                if?: string;
+            }, "match", "if">>(idOrOptions: import("inngest").StepOptionsOrId, opts: TOpts) => Promise<TOpts extends {
+                event: import("inngest").EventType<infer TName extends string, import("inngest").StandardSchemaV1<infer TData extends Record<string, unknown>>>;
+            } ? {
+                name: TName;
+                data: TData;
+                id: string;
+                ts: number;
+                v?: string;
+            } | null : TOpts extends {
+                event: import("inngest").EventType<infer TName_1 extends string, undefined>;
+            } ? {
+                name: TName_1;
+                data: Record<string, any>;
+                id: string;
+                ts: number;
+                v?: string;
+            } | null : TOpts extends {
+                event: infer TName_2 extends string;
+                schema: import("inngest").StandardSchemaV1<infer TData_1 extends Record<string, unknown>>;
+            } ? {
+                name: TName_2;
+                data: TData_1;
+                id: string;
+                ts: number;
+                v?: string;
+            } | null : TOpts extends {
+                event: infer TName_3 extends string;
+            } ? {
+                name: TName_3;
+                data: Record<string, any>;
+                id: string;
+                ts: number;
+                v?: string;
+            } | null : EventPayload<any> | null>;
+            run: <TFn extends (...args: any[]) => unknown>(idOrOptions: import("inngest").StepOptionsOrId, fn: TFn, ...input: Parameters<TFn>) => Promise<import("inngest/types").Jsonify<TFn extends (...args: Parameters<TFn>) => Promise<infer U> ? Awaited<U extends void ? null : U> : ReturnType<TFn> extends void ? null : ReturnType<TFn>>>;
+            ai: {
+                infer: <TAdapter extends import("inngest").AiAdapter>(idOrOptions: import("inngest").StepOptionsOrId, options: {
+                    model: TAdapter;
+                    body: import("inngest").AiAdapter.Input<TAdapter>;
+                }) => Promise<import("inngest").AiAdapter.Output<TAdapter>>;
+                wrap: <TFn extends (...args: any[]) => unknown>(idOrOptions: import("inngest").StepOptionsOrId, fn: TFn, ...input: Parameters<TFn>) => Promise<import("inngest/types").Jsonify<TFn extends (...args: Parameters<TFn>) => Promise<infer U> ? Awaited<U extends void ? null : U> : ReturnType<TFn> extends void ? null : ReturnType<TFn>>>;
+                models: {
+                    anthropic: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").Anthropic.AiModelOptions], import("inngest").Anthropic.AiModel>;
+                    gemini: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").Gemini.AiModelOptions], import("inngest").Gemini.AiModel>;
+                    openai: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").OpenAi.AiModelOptions], import("inngest").OpenAi.AiModel>;
+                    deepseek: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").DeepSeek.AiModelOptions], import("inngest").DeepSeek.AiModel>;
+                    grok: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").Grok.AiModelOptions], import("inngest").Grok.AiModel>;
+                };
+            };
+            sleep: (idOrOptions: import("inngest").StepOptionsOrId, time: number | string | import("inngest").DurationLike) => Promise<void>;
+            sleepUntil: (idOrOptions: import("inngest").StepOptionsOrId, time: Date | string | import("inngest").InstantLike | import("inngest").ZonedDateTimeLike) => Promise<void>;
+            invoke: <TFunction extends import("inngest/types").InvokeTargetFunctionDefinition>(idOrOptions: import("inngest").StepOptionsOrId, opts: {
+                function: TFunction;
+            } & Omit<import("inngest/types").TriggerEventFromFunction<TFunction>, "id"> & {
+                timeout?: number | string | Date | import("inngest").DurationLike | import("inngest").InstantLike | import("inngest").ZonedDateTimeLike;
+            }) => import("inngest/types").InvocationResult<import("inngest/types").Jsonify<import("inngest").GetFunctionOutputRaw<TFunction>>>;
+            fetch: import("inngest").StepFetch;
+        };
+    }>>, (ctx: any) => Promise<{
+        runId: string;
+        status: string;
+    }>, import("inngest").HandlerWithTriggers<{
+        sendEvent: (idOrOptions: import("inngest").StepOptionsOrId, payload: import("inngest").SendEventPayload) => Promise<import("inngest/types").SendEventOutput<import("inngest").ClientOptionsFromInngest<Inngest<import("inngest").ClientOptions>>>>;
+        waitForSignal: <TData>(idOrOptions: import("inngest").StepOptionsOrId, opts: {
+            signal: string;
+            timeout: number | string | Date | import("inngest").DurationLike | import("inngest").InstantLike | import("inngest").ZonedDateTimeLike;
+            onConflict: "replace" | "fail";
+        }) => Promise<{
+            signal: string;
+            data: import("inngest/types").Jsonify<TData>;
+        } | null>;
+        realtime: {
+            publish: <TData>(idOrOptions: import("inngest").StepOptionsOrId, topicRef: import("inngest").Realtime.TopicRef<TData>, data: TData) => Promise<TData>;
+        };
+        sendSignal: (idOrOptions: import("inngest").StepOptionsOrId, opts: {
+            signal: string;
+            data?: unknown;
+        }) => Promise<import("inngest/api/api").InngestApi.SendSignalResponse>;
+        waitForEvent: <TOpts extends {
+            event: string | import("inngest").EventType<string, any>;
+            timeout: number | string | Date | import("inngest").DurationLike | import("inngest").InstantLike | import("inngest").ZonedDateTimeLike;
+        } & import("inngest").ExclusiveKeys<{
+            match?: string;
+            if?: string;
+        }, "match", "if">>(idOrOptions: import("inngest").StepOptionsOrId, opts: TOpts) => Promise<TOpts extends {
+            event: import("inngest").EventType<infer TName extends string, import("inngest").StandardSchemaV1<infer TData extends Record<string, unknown>>>;
+        } ? {
+            name: TName;
+            data: TData;
+            id: string;
+            ts: number;
+            v?: string;
+        } | null : TOpts extends {
+            event: import("inngest").EventType<infer TName_1 extends string, undefined>;
+        } ? {
+            name: TName_1;
+            data: Record<string, any>;
+            id: string;
+            ts: number;
+            v?: string;
+        } | null : TOpts extends {
+            event: infer TName_2 extends string;
+            schema: import("inngest").StandardSchemaV1<infer TData_1 extends Record<string, unknown>>;
+        } ? {
+            name: TName_2;
+            data: TData_1;
+            id: string;
+            ts: number;
+            v?: string;
+        } | null : TOpts extends {
+            event: infer TName_3 extends string;
+        } ? {
+            name: TName_3;
+            data: Record<string, any>;
+            id: string;
+            ts: number;
+            v?: string;
+        } | null : EventPayload<any> | null>;
+        run: <TFn extends (...args: any[]) => unknown>(idOrOptions: import("inngest").StepOptionsOrId, fn: TFn, ...input: Parameters<TFn>) => Promise<import("inngest/types").Jsonify<TFn extends (...args: Parameters<TFn>) => Promise<infer U> ? Awaited<U extends void ? null : U> : ReturnType<TFn> extends void ? null : ReturnType<TFn>>>;
+        ai: {
+            infer: <TAdapter extends import("inngest").AiAdapter>(idOrOptions: import("inngest").StepOptionsOrId, options: {
+                model: TAdapter;
+                body: import("inngest").AiAdapter.Input<TAdapter>;
+            }) => Promise<import("inngest").AiAdapter.Output<TAdapter>>;
+            wrap: <TFn extends (...args: any[]) => unknown>(idOrOptions: import("inngest").StepOptionsOrId, fn: TFn, ...input: Parameters<TFn>) => Promise<import("inngest/types").Jsonify<TFn extends (...args: Parameters<TFn>) => Promise<infer U> ? Awaited<U extends void ? null : U> : ReturnType<TFn> extends void ? null : ReturnType<TFn>>>;
+            models: {
+                anthropic: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").Anthropic.AiModelOptions], import("inngest").Anthropic.AiModel>;
+                gemini: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").Gemini.AiModelOptions], import("inngest").Gemini.AiModel>;
+                openai: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").OpenAi.AiModelOptions], import("inngest").OpenAi.AiModel>;
+                deepseek: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").DeepSeek.AiModelOptions], import("inngest").DeepSeek.AiModel>;
+                grok: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").Grok.AiModelOptions], import("inngest").Grok.AiModel>;
+            };
+        };
+        sleep: (idOrOptions: import("inngest").StepOptionsOrId, time: number | string | import("inngest").DurationLike) => Promise<void>;
+        sleepUntil: (idOrOptions: import("inngest").StepOptionsOrId, time: Date | string | import("inngest").InstantLike | import("inngest").ZonedDateTimeLike) => Promise<void>;
+        invoke: <TFunction extends import("inngest/types").InvokeTargetFunctionDefinition>(idOrOptions: import("inngest").StepOptionsOrId, opts: {
+            function: TFunction;
+        } & Omit<import("inngest/types").TriggerEventFromFunction<TFunction>, "id"> & {
+            timeout?: number | string | Date | import("inngest").DurationLike | import("inngest").InstantLike | import("inngest").ZonedDateTimeLike;
+        }) => import("inngest/types").InvocationResult<import("inngest/types").Jsonify<import("inngest").GetFunctionOutputRaw<TFunction>>>;
+        fetch: import("inngest").StepFetch;
+    }, [{
+        readonly event: "xpod/run.requested";
+    }, {
+        readonly event: "xpod/run.continue_requested";
+    }], Omit<Omit<import("inngest").BaseContext<Inngest.Any>, never> & Record<never, never> & {
+        logger: import("inngest").Logger;
+    }, "group" | "requestId" | "runId" | "event" | "defer" | "events" | "jobId" | "step" | "attempt" | "maxAttempts"> & import("inngest").FailureEventArgs<EventPayload<any>> & {
+        step: {
+            sendEvent: (idOrOptions: import("inngest").StepOptionsOrId, payload: import("inngest").SendEventPayload) => Promise<import("inngest/types").SendEventOutput<import("inngest").ClientOptionsFromInngest<Inngest<import("inngest").ClientOptions>>>>;
+            waitForSignal: <TData>(idOrOptions: import("inngest").StepOptionsOrId, opts: {
+                signal: string;
+                timeout: number | string | Date | import("inngest").DurationLike | import("inngest").InstantLike | import("inngest").ZonedDateTimeLike;
+                onConflict: "replace" | "fail";
+            }) => Promise<{
+                signal: string;
+                data: import("inngest/types").Jsonify<TData>;
+            } | null>;
+            realtime: {
+                publish: <TData>(idOrOptions: import("inngest").StepOptionsOrId, topicRef: import("inngest").Realtime.TopicRef<TData>, data: TData) => Promise<TData>;
+            };
+            sendSignal: (idOrOptions: import("inngest").StepOptionsOrId, opts: {
+                signal: string;
+                data?: unknown;
+            }) => Promise<import("inngest/api/api").InngestApi.SendSignalResponse>;
+            waitForEvent: <TOpts extends {
+                event: string | import("inngest").EventType<string, any>;
+                timeout: number | string | Date | import("inngest").DurationLike | import("inngest").InstantLike | import("inngest").ZonedDateTimeLike;
+            } & import("inngest").ExclusiveKeys<{
+                match?: string;
+                if?: string;
+            }, "match", "if">>(idOrOptions: import("inngest").StepOptionsOrId, opts: TOpts) => Promise<TOpts extends {
+                event: import("inngest").EventType<infer TName extends string, import("inngest").StandardSchemaV1<infer TData extends Record<string, unknown>>>;
+            } ? {
+                name: TName;
+                data: TData;
+                id: string;
+                ts: number;
+                v?: string;
+            } | null : TOpts extends {
+                event: import("inngest").EventType<infer TName_1 extends string, undefined>;
+            } ? {
+                name: TName_1;
+                data: Record<string, any>;
+                id: string;
+                ts: number;
+                v?: string;
+            } | null : TOpts extends {
+                event: infer TName_2 extends string;
+                schema: import("inngest").StandardSchemaV1<infer TData_1 extends Record<string, unknown>>;
+            } ? {
+                name: TName_2;
+                data: TData_1;
+                id: string;
+                ts: number;
+                v?: string;
+            } | null : TOpts extends {
+                event: infer TName_3 extends string;
+            } ? {
+                name: TName_3;
+                data: Record<string, any>;
+                id: string;
+                ts: number;
+                v?: string;
+            } | null : EventPayload<any> | null>;
+            run: <TFn extends (...args: any[]) => unknown>(idOrOptions: import("inngest").StepOptionsOrId, fn: TFn, ...input: Parameters<TFn>) => Promise<import("inngest/types").Jsonify<TFn extends (...args: Parameters<TFn>) => Promise<infer U> ? Awaited<U extends void ? null : U> : ReturnType<TFn> extends void ? null : ReturnType<TFn>>>;
+            ai: {
+                infer: <TAdapter extends import("inngest").AiAdapter>(idOrOptions: import("inngest").StepOptionsOrId, options: {
+                    model: TAdapter;
+                    body: import("inngest").AiAdapter.Input<TAdapter>;
+                }) => Promise<import("inngest").AiAdapter.Output<TAdapter>>;
+                wrap: <TFn extends (...args: any[]) => unknown>(idOrOptions: import("inngest").StepOptionsOrId, fn: TFn, ...input: Parameters<TFn>) => Promise<import("inngest/types").Jsonify<TFn extends (...args: Parameters<TFn>) => Promise<infer U> ? Awaited<U extends void ? null : U> : ReturnType<TFn> extends void ? null : ReturnType<TFn>>>;
+                models: {
+                    anthropic: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").Anthropic.AiModelOptions], import("inngest").Anthropic.AiModel>;
+                    gemini: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").Gemini.AiModelOptions], import("inngest").Gemini.AiModel>;
+                    openai: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").OpenAi.AiModelOptions], import("inngest").OpenAi.AiModel>;
+                    deepseek: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").DeepSeek.AiModelOptions], import("inngest").DeepSeek.AiModel>;
+                    grok: import("inngest").AiAdapter.ModelCreator<[options: import("inngest").Grok.AiModelOptions], import("inngest").Grok.AiModel>;
+                };
+            };
+            sleep: (idOrOptions: import("inngest").StepOptionsOrId, time: number | string | import("inngest").DurationLike) => Promise<void>;
+            sleepUntil: (idOrOptions: import("inngest").StepOptionsOrId, time: Date | string | import("inngest").InstantLike | import("inngest").ZonedDateTimeLike) => Promise<void>;
+            invoke: <TFunction extends import("inngest/types").InvokeTargetFunctionDefinition>(idOrOptions: import("inngest").StepOptionsOrId, opts: {
+                function: TFunction;
+            } & Omit<import("inngest/types").TriggerEventFromFunction<TFunction>, "id"> & {
+                timeout?: number | string | Date | import("inngest").DurationLike | import("inngest").InstantLike | import("inngest").ZonedDateTimeLike;
+            }) => import("inngest/types").InvocationResult<import("inngest/types").Jsonify<import("inngest").GetFunctionOutputRaw<TFunction>>>;
+            fetch: import("inngest").StepFetch;
+        };
+    }>, Inngest<import("inngest").ClientOptions>, [{
+        readonly event: "xpod/run.requested";
+    }, {
+        readonly event: "xpod/run.continue_requested";
+    }]>;
+    constructor(options?: InngestRunExecutionBackendOptions);
+    getClient(): Inngest;
+    start(input: RunExecutionInput): AsyncIterable<AgentRuntimeEvent>;
+    private handleAgentRun;
+    restoreExecutionInput(runId: string, context: StoreContext): Promise<RunExecutionInput>;
+    private createInlineContext;
+    private formatError;
+    private executionKeyForInput;
+    private contextEventData;
+}

package/dist/api/runs/InngestRunExecutionBackend.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InngestRunExecutionBackend = exports.XPOD_AGENT_RUN_FUNCTION_ID = exports.XPOD_RUN_CONTINUE_REQUESTED_EVENT = exports.XPOD_RUN_REQUESTED_EVENT = void 0;
+const inngest_1 = require("inngest");
+const ManagedRunWorker_1 = require("./ManagedRunWorker");
+const PiAgentRuntimeDriver_1 = require("./PiAgentRuntimeDriver");
+exports.XPOD_RUN_REQUESTED_EVENT = 'xpod/run.requested';
+exports.XPOD_RUN_CONTINUE_REQUESTED_EVENT = 'xpod/run.continue_requested';
+exports.XPOD_AGENT_RUN_FUNCTION_ID = 'xpod-agent-run';
+/**
+ * Inngest-backed managed-agent execution backend.
+ *
+ * Xpod owns the Run facts; Inngest owns durable function delivery. In this
+ * first API-facing implementation the function can execute inline so ChatKit
+ * still receives a normal SSE stream without waiting for external polling.
+ *
+ * The in-memory pending map is only the streaming bridge for an active HTTP
+ * request. When no pending stream exists, the registered Inngest function can
+ * restore the Run from store through ManagedRunWorker.
+ */
+class InngestRunExecutionBackend {
+    constructor(options = {}) {
+        this.pendingRuns = new Map();
+        this.client = options.client ?? new inngest_1.Inngest({
+            id: 'xpod-managed-agents',
+            baseUrl: options.baseUrl,
+            eventKey: options.eventKey,
+            signingKey: options.signingKey,
+            isDev: true,
+        });
+        this.runtimeDriver = options.runtimeDriver ?? new PiAgentRuntimeDriver_1.PiAgentRuntimeDriver();
+        this.managedRunWorker = options.managedRunWorker
+            ?? (options.store ? new ManagedRunWorker_1.ManagedRunWorker({ store: options.store, runtimeDriver: this.runtimeDriver }) : undefined);
+        this.contextResolver = options.contextResolver;
+        this.contextRecorder = options.contextRecorder;
+        this.durableDelivery = options.durableDelivery ?? true;
+        this.executeInline = options.executeInline ?? true;
+        this.agentRunFunction = this.client.createFunction({
+            id: exports.XPOD_AGENT_RUN_FUNCTION_ID,
+            name: 'Xpod Agent Run',
+            triggers: [
+                { event: exports.XPOD_RUN_REQUESTED_EVENT },
+                { event: exports.XPOD_RUN_CONTINUE_REQUESTED_EVENT },
+            ],
+            idempotency: 'event.data.executionKey',
+        }, (ctx) => this.handleAgentRun(ctx));
+    }
+    getClient() {
+        return this.client;
+    }
+    async *start(input) {
+        const queue = new AsyncPushQueue();
+        this.pendingRuns.set(input.runId, { input, queue, started: false });
+        const context = input.context;
+        this.contextRecorder?.(context);
+        const eventName = input.continuation
+            ? exports.XPOD_RUN_CONTINUE_REQUESTED_EVENT
+            : exports.XPOD_RUN_REQUESTED_EVENT;
+        const executionKey = this.executionKeyForInput(input);
+        try {
+            if (!this.durableDelivery && !this.executeInline) {
+                yield {
+                    type: 'error',
+                    message: 'Run execution backend has neither durable delivery nor inline execution enabled',
+                };
+                return;
+            }
+            if (this.durableDelivery) {
+                await this.client.send({
+                    id: executionKey,
+                    name: eventName,
+                    data: {
+                        runId: input.runId,
+                        threadId: input.threadId,
+                        executionKey,
+                        continuation: input.continuation,
+                        ...this.contextEventData(input, context),
+                    },
+                });
+            }
+            if (!this.executeInline) {
+                queue.close();
+                return;
+            }
+            if (this.executeInline) {
+                void this.handleAgentRun(this.createInlineContext(input)).catch((error) => {
+                    queue.push({ type: 'error', message: this.formatError(error) });
+                    queue.close();
+                });
+            }
+            for await (const event of queue.iterate()) {
+                yield event;
+            }
+        }
+        catch (error) {
+            yield { type: 'error', message: this.formatError(error) };
+        }
+        finally {
+            this.pendingRuns.delete(input.runId);
+            queue.close();
+        }
+    }
+    async handleAgentRun(ctx) {
+        const runId = ctx.event.data?.runId;
+        if (!runId) {
+            return { runId: 'unknown', status: 'missing_run_id' };
+        }
+        const pending = this.pendingRuns.get(runId);
+        if (pending) {
+            if (pending.started) {
+                return { runId, status: 'skipped' };
+            }
+            pending.started = true;
+            await ctx.step.run('run-agent', async () => {
+                try {
+                    for await (const event of this.runtimeDriver.start(pending.input)) {
+                        pending.queue.push(event);
+                    }
+                }
+                finally {
+                    pending.queue.close();
+                }
+            });
+            return { runId, status: 'completed' };
+        }
+        if (!this.managedRunWorker || !this.contextResolver) {
+            return { runId, status: 'not_found' };
+        }
+        const context = await this.contextResolver(ctx.event.data);
+        if (!context) {
+            return { runId, status: 'not_found' };
+        }
+        const result = await ctx.step.run('run-agent-from-store', async () => {
+            return this.managedRunWorker.executeRun(runId, context);
+        });
+        return { runId, status: result.status };
+    }
+    async restoreExecutionInput(runId, context) {
+        if (!this.managedRunWorker) {
+            throw new Error('Managed Run worker is not configured');
+        }
+        return this.managedRunWorker.loadExecutionInput(runId, context);
+    }
+    createInlineContext(input) {
+        const executionKey = this.executionKeyForInput(input);
+        return {
+            event: {
+                id: executionKey,
+                name: input.continuation ? exports.XPOD_RUN_CONTINUE_REQUESTED_EVENT : exports.XPOD_RUN_REQUESTED_EVENT,
+                data: {
+                    runId: input.runId,
+                    threadId: input.threadId,
+                    executionKey,
+                    continuation: input.continuation,
+                    ...this.contextEventData(input, input.context),
+                },
+            },
+            runId: `inline:${executionKey}`,
+            step: {
+                run: async (_id, fn) => fn(),
+            },
+        };
+    }
+    formatError(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+    executionKeyForInput(input) {
+        if (!input.continuation) {
+            return `run:${input.runId}`;
+        }
+        return `run:${input.runId}:continue:${input.continuation.kind}:${input.continuation.itemId ?? 'none'}`;
+    }
+    contextEventData(input, context) {
+        const auth = context?.auth;
+        if (input.authBindingId) {
+            return {
+                authBindingId: input.authBindingId,
+                ...(auth?.type === 'solid' && typeof auth.webId === 'string' ? { webId: auth.webId } : {}),
+            };
+        }
+        if (auth?.type !== 'solid' || typeof auth.webId !== 'string') {
+            return {};
+        }
+        return { webId: auth.webId };
+    }
+}
+exports.InngestRunExecutionBackend = InngestRunExecutionBackend;
+class AsyncPushQueue {
+    constructor() {
+        this.items = [];
+        this.resolvers = [];
+        this.closed = false;
+    }
+    push(item) {
+        if (this.closed) {
+            return;
+        }
+        this.items.push(item);
+        const resolver = this.resolvers.shift();
+        resolver?.();
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        for (const resolver of this.resolvers) {
+            resolver();
+        }
+        this.resolvers = [];
+    }
+    async *iterate() {
+        while (true) {
+            if (this.items.length > 0) {
+                yield this.items.shift();
+                continue;
+            }
+            if (this.closed) {
+                return;
+            }
+            await new Promise((resolve) => this.resolvers.push(resolve));
+        }
+    }
+}
+//# sourceMappingURL=InngestRunExecutionBackend.js.map