@trigger.dev/react-hooks 3.1.2 → 3.2.1

package/dist/commonjs/hooks/useTaskTrigger.d.ts

@@ -0,0 +1,101 @@
+import { type AnyTask, type TaskIdentifier, type TaskPayload, InferRunTypes, RunHandleFromTypes } from "@trigger.dev/core/v3";
+import { UseApiClientOptions } from "./useApiClient.js";
+import { UseRealtimeRunInstance, UseRealtimeRunWithStreamsInstance } from "./useRealtime.js";
+/**
+ * Base interface for task trigger instances.
+ *
+ * @template TTask - The type of the task
+ */
+export interface TriggerInstance<TTask extends AnyTask> {
+    /** Function to submit the task with a payload */
+    submit: (payload: TaskPayload<TTask>) => void;
+    /** Whether the task is currently being submitted */
+    isLoading: boolean;
+    /** The handle returned after successful task submission */
+    handle?: RunHandleFromTypes<InferRunTypes<TTask>>;
+    /** Any error that occurred during submission */
+    error?: Error;
+}
+export type UseTaskTriggerOptions = UseApiClientOptions;
+/**
+ * Hook to trigger a task and manage its initial execution state.
+ *
+ * @template TTask - The type of the task
+ * @param {TaskIdentifier<TTask>} id - The identifier of the task to trigger
+ * @param {UseTaskTriggerOptions} [options] - Configuration options for the task trigger
+ * @returns {TriggerInstance<TTask>} An object containing the submit function, loading state, handle, and any errors
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { submit, isLoading, handle, error } = useTaskTrigger<typeof myTask>('my-task-id');
+ *
+ * // Submit the task with payload
+ * submit({ foo: 'bar' });
+ * ```
+ */
+export declare function useTaskTrigger<TTask extends AnyTask>(id: TaskIdentifier<TTask>, options?: UseTaskTriggerOptions): TriggerInstance<TTask>;
+/**
+ * Configuration options for task triggers with realtime updates.
+ */
+export type UseRealtimeTaskTriggerOptions = UseTaskTriggerOptions & {
+    /** Whether the realtime subscription is enabled */
+    enabled?: boolean;
+    /** Optional throttle time in milliseconds for stream updates */
+    experimental_throttleInMs?: number;
+};
+export type RealtimeTriggerInstanceWithStreams<TTask extends AnyTask, TStreams extends Record<string, any> = Record<string, any>> = UseRealtimeRunWithStreamsInstance<TTask, TStreams> & {
+    submit: (payload: TaskPayload<TTask>) => void;
+    isLoading: boolean;
+    handle?: RunHandleFromTypes<InferRunTypes<TTask>>;
+};
+/**
+ * Hook to trigger a task and subscribe to its realtime updates including stream data.
+ *
+ * @template TTask - The type of the task
+ * @template TStreams - The type of the streams data
+ * @param {TaskIdentifier<TTask>} id - The identifier of the task to trigger
+ * @param {UseRealtimeTaskTriggerOptions} [options] - Configuration options for the task trigger and realtime updates
+ * @returns {RealtimeTriggerInstanceWithStreams<TTask, TStreams>} An object containing the submit function, loading state,
+ *          handle, run state, streams data, and error handling
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { submit, run, streams, error } = useRealtimeTaskTriggerWithStreams<
+ *   typeof myTask,
+ *   { output: string }
+ * >('my-task-id');
+ *
+ * // Submit and monitor the task with streams
+ * submit({ foo: 'bar' });
+ * ```
+ */
+export declare function useRealtimeTaskTriggerWithStreams<TTask extends AnyTask, TStreams extends Record<string, any> = Record<string, any>>(id: TaskIdentifier<TTask>, options?: UseRealtimeTaskTriggerOptions): RealtimeTriggerInstanceWithStreams<TTask, TStreams>;
+export type RealtimeTriggerInstance<TTask extends AnyTask> = UseRealtimeRunInstance<TTask> & {
+    submit: (payload: TaskPayload<TTask>) => void;
+    isLoading: boolean;
+    handle?: RunHandleFromTypes<InferRunTypes<TTask>>;
+};
+/**
+ * Hook to trigger a task and subscribe to its realtime updates.
+ *
+ * @template TTask - The type of the task
+ * @param {TaskIdentifier<TTask>} id - The identifier of the task to trigger
+ * @param {UseRealtimeTaskTriggerOptions} [options] - Configuration options for the task trigger and realtime updates
+ * @returns {RealtimeTriggerInstance<TTask>} An object containing the submit function, loading state,
+ *          handle, run state, and error handling
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { submit, run, error, stop } = useRealtimeTaskTrigger<typeof myTask>('my-task-id');
+ *
+ * // Submit and monitor the task
+ * submit({ foo: 'bar' });
+ *
+ * // Stop monitoring when needed
+ * stop();
+ * ```
+ */
+export declare function useRealtimeTaskTrigger<TTask extends AnyTask>(id: TaskIdentifier<TTask>, options?: UseRealtimeTaskTriggerOptions): RealtimeTriggerInstance<TTask>;

package/dist/commonjs/hooks/useTaskTrigger.js

@@ -0,0 +1,134 @@
+"use client";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTaskTrigger = useTaskTrigger;
+exports.useRealtimeTaskTriggerWithStreams = useRealtimeTaskTriggerWithStreams;
+exports.useRealtimeTaskTrigger = useRealtimeTaskTrigger;
+const v3_1 = require("@trigger.dev/core/v3");
+const mutation_1 = __importDefault(require("swr/mutation"));
+const useApiClient_js_1 = require("./useApiClient.js");
+const useRealtime_js_1 = require("./useRealtime.js");
+/**
+ * Hook to trigger a task and manage its initial execution state.
+ *
+ * @template TTask - The type of the task
+ * @param {TaskIdentifier<TTask>} id - The identifier of the task to trigger
+ * @param {UseTaskTriggerOptions} [options] - Configuration options for the task trigger
+ * @returns {TriggerInstance<TTask>} An object containing the submit function, loading state, handle, and any errors
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { submit, isLoading, handle, error } = useTaskTrigger<typeof myTask>('my-task-id');
+ *
+ * // Submit the task with payload
+ * submit({ foo: 'bar' });
+ * ```
+ */
+function useTaskTrigger(id, options) {
+    const apiClient = (0, useApiClient_js_1.useApiClient)(options);
+    async function triggerTask(id, { arg: { payload, options }, }) {
+        const payloadPacket = await (0, v3_1.stringifyIO)(payload);
+        const handle = await apiClient.triggerTask(id, {
+            payload: payloadPacket.data,
+            options: {
+                queue: options?.queue,
+                concurrencyKey: options?.concurrencyKey,
+                payloadType: payloadPacket.dataType,
+                idempotencyKey: await (0, v3_1.makeIdempotencyKey)(options?.idempotencyKey),
+                delay: options?.delay,
+                ttl: options?.ttl,
+                tags: options?.tags,
+                maxAttempts: options?.maxAttempts,
+                metadata: options?.metadata,
+                maxDuration: options?.maxDuration,
+            },
+        });
+        return { ...handle, taskIdentifier: id };
+    }
+    const mutation = (0, mutation_1.default)(id, triggerTask);
+    return {
+        submit: (payload) => {
+            // trigger the task with the given payload
+            mutation.trigger({ payload });
+        },
+        isLoading: mutation.isMutating,
+        handle: mutation.data,
+        error: mutation.error,
+    };
+}
+/**
+ * Hook to trigger a task and subscribe to its realtime updates including stream data.
+ *
+ * @template TTask - The type of the task
+ * @template TStreams - The type of the streams data
+ * @param {TaskIdentifier<TTask>} id - The identifier of the task to trigger
+ * @param {UseRealtimeTaskTriggerOptions} [options] - Configuration options for the task trigger and realtime updates
+ * @returns {RealtimeTriggerInstanceWithStreams<TTask, TStreams>} An object containing the submit function, loading state,
+ *          handle, run state, streams data, and error handling
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { submit, run, streams, error } = useRealtimeTaskTriggerWithStreams<
+ *   typeof myTask,
+ *   { output: string }
+ * >('my-task-id');
+ *
+ * // Submit and monitor the task with streams
+ * submit({ foo: 'bar' });
+ * ```
+ */
+function useRealtimeTaskTriggerWithStreams(id, options) {
+    const triggerInstance = useTaskTrigger(id, options);
+    const realtimeInstance = (0, useRealtime_js_1.useRealtimeRunWithStreams)(triggerInstance.handle?.id, {
+        ...options,
+        id: triggerInstance.handle?.id,
+        accessToken: triggerInstance.handle?.publicAccessToken ?? options?.accessToken,
+    });
+    return {
+        ...realtimeInstance,
+        ...triggerInstance,
+    };
+}
+/**
+ * Hook to trigger a task and subscribe to its realtime updates.
+ *
+ * @template TTask - The type of the task
+ * @param {TaskIdentifier<TTask>} id - The identifier of the task to trigger
+ * @param {UseRealtimeTaskTriggerOptions} [options] - Configuration options for the task trigger and realtime updates
+ * @returns {RealtimeTriggerInstance<TTask>} An object containing the submit function, loading state,
+ *          handle, run state, and error handling
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { submit, run, error, stop } = useRealtimeTaskTrigger<typeof myTask>('my-task-id');
+ *
+ * // Submit and monitor the task
+ * submit({ foo: 'bar' });
+ *
+ * // Stop monitoring when needed
+ * stop();
+ * ```
+ */
+function useRealtimeTaskTrigger(id, options) {
+    const triggerInstance = useTaskTrigger(id, options);
+    const realtimeInstance = (0, useRealtime_js_1.useRealtimeRun)(triggerInstance.handle?.id, {
+        ...options,
+        id: triggerInstance.handle?.id,
+        accessToken: triggerInstance.handle?.publicAccessToken ?? options?.accessToken,
+    });
+    return {
+        submit: triggerInstance.submit,
+        isLoading: triggerInstance.isLoading,
+        handle: triggerInstance.handle,
+        run: realtimeInstance.run,
+        error: realtimeInstance.error ?? triggerInstance.error,
+        stop: realtimeInstance.stop,
+    };
+}
+//# sourceMappingURL=useTaskTrigger.js.map

package/dist/commonjs/hooks/useTaskTrigger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTaskTrigger.js","sourceRoot":"","sources":["../../../src/hooks/useTaskTrigger.ts"],"names":[],"mappings":"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"}

package/dist/commonjs/index.d.ts

@@ -1,6 +1,5 @@
 export * from "./contexts.js";
 export * from "./hooks/useApiClient.js";
 export * from "./hooks/useRun.js";
-export * from "./hooks/useRealtimeRun.js";
-export * from "./hooks/useRealtimeRunsWithTag.js";
-export * from "./hooks/useRealtimeBatch.js";
+export * from "./hooks/useRealtime.js";
+export * from "./hooks/useTaskTrigger.js";

package/dist/commonjs/index.js

@@ -17,7 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./contexts.js"), exports);
 __exportStar(require("./hooks/useApiClient.js"), exports);
 __exportStar(require("./hooks/useRun.js"), exports);
-__exportStar(require("./hooks/useRealtimeRun.js"), exports);
-__exportStar(require("./hooks/useRealtimeRunsWithTag.js"), exports);
-__exportStar(require("./hooks/useRealtimeBatch.js"), exports);
+__exportStar(require("./hooks/useRealtime.js"), exports);
+__exportStar(require("./hooks/useTaskTrigger.js"), exports);
 //# sourceMappingURL=index.js.map

package/dist/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,gDAA8B;AAC9B,0DAAwC;AACxC,oDAAkC;AAClC,4DAA0C;AAC1C,oEAAkD;AAClD,8DAA4C"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,gDAA8B;AAC9B,0DAAwC;AACxC,oDAAkC;AAClC,yDAAuC;AACvC,4DAA0C"}

package/dist/commonjs/utils/throttle.d.ts

@@ -0,0 +1,6 @@
+export type ThrottledQueue<T> = {
+    add: (item: T) => void;
+    flush: () => Promise<void>;
+    isEmpty: () => boolean;
+};
+export declare function createThrottledQueue<T>(onFlush: (items: T[]) => Promise<void>, throttleInMs?: number): ThrottledQueue<T>;

package/dist/commonjs/utils/throttle.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createThrottledQueue = createThrottledQueue;
+function createThrottledQueue(onFlush, throttleInMs) {
+    let queue = [];
+    let lastFlushTime = 0;
+    let flushPromise = null;
+    const scheduleFlush = async () => {
+        // If no throttle specified or there's already a flush in progress, return
+        if (!throttleInMs) {
+            // Immediately flush when no throttling is specified
+            const itemsToFlush = [...queue];
+            queue = [];
+            await onFlush(itemsToFlush);
+            return;
+        }
+        if (queue.length === 0 || flushPromise)
+            return;
+        const now = Date.now();
+        const timeUntilNextFlush = Math.max(0, lastFlushTime + throttleInMs - now);
+        if (timeUntilNextFlush === 0) {
+            const itemsToFlush = [...queue];
+            queue = [];
+            lastFlushTime = now;
+            flushPromise = onFlush(itemsToFlush).finally(() => {
+                flushPromise = null;
+                // Check if more items accumulated during flush
+                scheduleFlush();
+            });
+        }
+        else {
+            setTimeout(scheduleFlush, timeUntilNextFlush);
+        }
+    };
+    return {
+        add: (item) => {
+            queue.push(item);
+            scheduleFlush();
+        },
+        flush: async () => {
+            if (queue.length === 0)
+                return;
+            const itemsToFlush = [...queue];
+            queue = [];
+            await onFlush(itemsToFlush);
+        },
+        isEmpty: () => queue.length === 0,
+    };
+}
+//# sourceMappingURL=throttle.js.map

package/dist/commonjs/utils/throttle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttle.js","sourceRoot":"","sources":["../../../src/utils/throttle.ts"],"names":[],"mappings":";;AAOA,oDAkDC;AAlDD,SAAgB,oBAAoB,CAClC,OAAsC,EACtC,YAAqB;IAErB,IAAI,KAAK,GAAQ,EAAE,CAAC;IACpB,IAAI,aAAa,GAAG,CAAC,CAAC;IACtB,IAAI,YAAY,GAAyB,IAAI,CAAC;IAE9C,MAAM,aAAa,GAAG,KAAK,IAAI,EAAE;QAC/B,0EAA0E;QAC1E,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,oDAAoD;YACpD,MAAM,YAAY,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;YAChC,KAAK,GAAG,EAAE,CAAC;YACX,MAAM,OAAO,CAAC,YAAY,CAAC,CAAC;YAC5B,OAAO;QACT,CAAC;QAED,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,YAAY;YAAE,OAAO;QAE/C,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,MAAM,kBAAkB,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,aAAa,GAAG,YAAY,GAAG,GAAG,CAAC,CAAC;QAE3E,IAAI,kBAAkB,KAAK,CAAC,EAAE,CAAC;YAC7B,MAAM,YAAY,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;YAChC,KAAK,GAAG,EAAE,CAAC;YACX,aAAa,GAAG,GAAG,CAAC;YACpB,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;gBAChD,YAAY,GAAG,IAAI,CAAC;gBACpB,+CAA+C;gBAC/C,aAAa,EAAE,CAAC;YAClB,CAAC,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,UAAU,CAAC,aAAa,EAAE,kBAAkB,CAAC,CAAC;QAChD,CAAC;IACH,CAAC,CAAC;IAEF,OAAO;QACL,GAAG,EAAE,CAAC,IAAO,EAAE,EAAE;YACf,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACjB,aAAa,EAAE,CAAC;QAClB,CAAC;QACD,KAAK,EAAE,KAAK,IAAI,EAAE;YAChB,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO;YAC/B,MAAM,YAAY,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;YAChC,KAAK,GAAG,EAAE,CAAC;YACX,MAAM,OAAO,CAAC,YAAY,CAAC,CAAC;QAC9B,CAAC;QACD,OAAO,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC;KAClC,CAAC;AACJ,CAAC"}

package/dist/commonjs/utils/trigger-swr.d.ts

@@ -1,7 +1,19 @@
+import { ApiRequestOptions } from "@trigger.dev/core/v3";
 export * from "swr";
 export { default as useSWR, SWRConfig } from "swr";
 export type CommonTriggerHookOptions = {
+    /**
+     * Poll for updates at the specified interval (in milliseconds). Polling is not recommended for most use-cases. Use the Realtime hooks instead.
+     */
     refreshInterval?: number;
+    /** Revalidate the data when the browser regains a network connection. */
     revalidateOnReconnect?: boolean;
+    /** Revalidate the data when the window regains focus. */
     revalidateOnFocus?: boolean;
+    /** Optional access token for authentication */
+    accessToken?: string;
+    /** Optional base URL for the API endpoints */
+    baseURL?: string;
+    /** Optional additional request configuration */
+    requestOptions?: ApiRequestOptions;
 };

package/dist/commonjs/utils/trigger-swr.js.map

@@ -1 +1 @@
-{"version":3,"file":"trigger-swr.js","sourceRoot":"","sources":["../../../src/utils/trigger-swr.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;AACb,yCAAyC;AACzC,sCAAoB;AACpB,yCAAyC;AACzC,2BAAmD;AAA1C,8GAAA,OAAO,OAAU;AAAE,gGAAA,SAAS,OAAA"}
+{"version":3,"file":"trigger-swr.js","sourceRoot":"","sources":["../../../src/utils/trigger-swr.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;AAIb,yCAAyC;AACzC,sCAAoB;AACpB,yCAAyC;AACzC,2BAAmD;AAA1C,8GAAA,OAAO,OAAU;AAAE,gGAAA,SAAS,OAAA"}

package/dist/esm/contexts.d.ts

@@ -1,4 +1,4 @@
 import React from "react";
 import type { ApiClientConfiguration } from "@trigger.dev/core/v3";
-declare const TriggerAuthContext: React.Context<ApiClientConfiguration | undefined>, useTriggerAuthContext: () => ApiClientConfiguration;
-export { TriggerAuthContext, useTriggerAuthContext };
+declare const TriggerAuthContext: React.Context<ApiClientConfiguration | undefined>, useTriggerAuthContext: () => ApiClientConfiguration, useTriggerAuthContextOptional: () => ApiClientConfiguration | Partial<ApiClientConfiguration>;
+export { TriggerAuthContext, useTriggerAuthContext, useTriggerAuthContextOptional };

package/dist/esm/contexts.js

@@ -1,5 +1,5 @@
 "use client";
 import { createContextAndHook } from "./utils/createContextAndHook.js";
-const [TriggerAuthContext, useTriggerAuthContext] = createContextAndHook("TriggerAuthContext");
-export { TriggerAuthContext, useTriggerAuthContext };
+const [TriggerAuthContext, useTriggerAuthContext, useTriggerAuthContextOptional] = createContextAndHook("TriggerAuthContext");
+export { TriggerAuthContext, useTriggerAuthContext, useTriggerAuthContextOptional };
 //# sourceMappingURL=contexts.js.map

package/dist/esm/contexts.js.map

@@ -1 +1 @@
-{"version":3,"file":"contexts.js","sourceRoot":"","sources":["../../src/contexts.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAGb,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAGvE,MAAM,CAAC,kBAAkB,EAAE,qBAAqB,CAAC,GAC/C,oBAAoB,CAAyB,oBAAoB,CAAC,CAAC;AAErE,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,CAAC"}
+{"version":3,"file":"contexts.js","sourceRoot":"","sources":["../../src/contexts.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAGb,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAGvE,MAAM,CAAC,kBAAkB,EAAE,qBAAqB,EAAE,6BAA6B,CAAC,GAC9E,oBAAoB,CAAyB,oBAAoB,CAAC,CAAC;AAErE,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,CAAC"}

package/dist/esm/hooks/useApiClient.d.ts

@@ -1,2 +1,33 @@
-import { ApiClient } from "@trigger.dev/core/v3";
-export declare function useApiClient(): ApiClient;
+import { ApiClient, ApiRequestOptions } from "@trigger.dev/core/v3";
+/**
+ * Configuration options for creating an API client instance.
+ */
+export type UseApiClientOptions = {
+    /** Optional access token for authentication */
+    accessToken?: string;
+    /** Optional base URL for the API endpoints */
+    baseURL?: string;
+    /** Optional additional request configuration */
+    requestOptions?: ApiRequestOptions;
+};
+/**
+ * Hook to create an API client instance using authentication context or provided options.
+ *
+ * @param {UseApiClientOptions} [options] - Configuration options for the API client
+ * @returns {ApiClient} An initialized API client instance
+ * @throws {Error} When no access token is available in either context or options
+ *
+ * @example
+ * ```ts
+ * // Using context authentication
+ * const apiClient = useApiClient();
+ *
+ * // Using custom options
+ * const apiClient = useApiClient({
+ *   accessToken: "your-access-token",
+ *   baseURL: "https://api.my-trigger.com",
+ *   requestOptions: { retry: { maxAttempts: 10 } }
+ * });
+ * ```
+ */
+export declare function useApiClient(options?: UseApiClientOptions): ApiClient;

package/dist/esm/hooks/useApiClient.js

@@ -1,12 +1,37 @@
 "use client";
 import { ApiClient } from "@trigger.dev/core/v3";
-import { useTriggerAuthContext } from "../contexts.js";
-export function useApiClient() {
-    const auth = useTriggerAuthContext();
-    const baseUrl = auth.baseURL ?? "https://api.trigger.dev";
-    if (!auth.accessToken) {
-        throw new Error("Missing accessToken in TriggerAuthContext");
+import { useTriggerAuthContextOptional } from "../contexts.js";
+/**
+ * Hook to create an API client instance using authentication context or provided options.
+ *
+ * @param {UseApiClientOptions} [options] - Configuration options for the API client
+ * @returns {ApiClient} An initialized API client instance
+ * @throws {Error} When no access token is available in either context or options
+ *
+ * @example
+ * ```ts
+ * // Using context authentication
+ * const apiClient = useApiClient();
+ *
+ * // Using custom options
+ * const apiClient = useApiClient({
+ *   accessToken: "your-access-token",
+ *   baseURL: "https://api.my-trigger.com",
+ *   requestOptions: { retry: { maxAttempts: 10 } }
+ * });
+ * ```
+ */
+export function useApiClient(options) {
+    const auth = useTriggerAuthContextOptional();
+    const baseUrl = options?.baseURL ?? auth?.baseURL ?? "https://api.trigger.dev";
+    const accessToken = options?.accessToken ?? auth?.accessToken;
+    if (!accessToken) {
+        throw new Error("Missing accessToken in TriggerAuthContext or useApiClient options");
     }
-    return new ApiClient(baseUrl, auth.accessToken, auth.requestOptions);
+    const requestOptions = {
+        ...auth?.requestOptions,
+        ...options?.requestOptions,
+    };
+    return new ApiClient(baseUrl, accessToken, requestOptions);
 }
 //# sourceMappingURL=useApiClient.js.map

package/dist/esm/hooks/useApiClient.js.map

@@ -1 +1 @@
-{"version":3,"file":"useApiClient.js","sourceRoot":"","sources":["../../../src/hooks/useApiClient.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,MAAM,UAAU,YAAY;IAC1B,MAAM,IAAI,GAAG,qBAAqB,EAAE,CAAC;IAErC,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,yBAAyB,CAAC;IAE1D,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;IAC/D,CAAC;IAED,OAAO,IAAI,SAAS,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;AACvE,CAAC"}
+{"version":3,"file":"useApiClient.js","sourceRoot":"","sources":["../../../src/hooks/useApiClient.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb,OAAO,EAAE,SAAS,EAAqB,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAC;AAc/D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,YAAY,CAAC,OAA6B;IACxD,MAAM,IAAI,GAAG,6BAA6B,EAAE,CAAC;IAE7C,MAAM,OAAO,GAAG,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,OAAO,IAAI,yBAAyB,CAAC;IAC/E,MAAM,WAAW,GAAG,OAAO,EAAE,WAAW,IAAI,IAAI,EAAE,WAAW,CAAC;IAE9D,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CAAC,mEAAmE,CAAC,CAAC;IACvF,CAAC;IAED,MAAM,cAAc,GAAsB;QACxC,GAAG,IAAI,EAAE,cAAc;QACvB,GAAG,OAAO,EAAE,cAAc;KAC3B,CAAC;IAEF,OAAO,IAAI,SAAS,CAAC,OAAO,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC;AAC7D,CAAC"}

package/dist/esm/hooks/useRealtime.d.ts

@@ -0,0 +1,100 @@
+import { AnyTask, RealtimeRun } from "@trigger.dev/core/v3";
+import { UseApiClientOptions } from "./useApiClient.js";
+export type UseRealtimeRunOptions = UseApiClientOptions & {
+    id?: string;
+    enabled?: boolean;
+    experimental_throttleInMs?: number;
+};
+export type UseRealtimeRunInstance<TTask extends AnyTask = AnyTask> = {
+    run: RealtimeRun<TTask> | undefined;
+    error: Error | undefined;
+    /**
+     * Abort the current request immediately.
+     */
+    stop: () => void;
+};
+/**
+ * Hook to subscribe to realtime updates of a task run.
+ *
+ * @template TTask - The type of the task
+ * @param {string} [runId] - The unique identifier of the run to subscribe to
+ * @param {UseRealtimeRunOptions} [options] - Configuration options for the subscription
+ * @returns {UseRealtimeRunInstance<TTask>} An object containing the current state of the run, error handling, and control methods
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { run, error } = useRealtimeRun<typeof myTask>('run-id-123');
+ * ```
+ */
+export declare function useRealtimeRun<TTask extends AnyTask>(runId?: string, options?: UseRealtimeRunOptions): UseRealtimeRunInstance<TTask>;
+export type StreamResults<TStreams extends Record<string, any>> = {
+    [K in keyof TStreams]: Array<TStreams[K]>;
+};
+export type UseRealtimeRunWithStreamsInstance<TTask extends AnyTask = AnyTask, TStreams extends Record<string, any> = Record<string, any>> = {
+    run: RealtimeRun<TTask> | undefined;
+    streams: StreamResults<TStreams>;
+    error: Error | undefined;
+    /**
+     * Abort the current request immediately, keep the generated tokens if any.
+     */
+    stop: () => void;
+};
+/**
+ * Hook to subscribe to realtime updates of a task run with associated data streams.
+ *
+ * @template TTask - The type of the task
+ * @template TStreams - The type of the streams data
+ * @param {string} [runId] - The unique identifier of the run to subscribe to
+ * @param {UseRealtimeRunOptions} [options] - Configuration options for the subscription
+ * @returns {UseRealtimeRunWithStreamsInstance<TTask, TStreams>} An object containing the current state of the run, streams data, and error handling
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { run, streams, error } = useRealtimeRunWithStreams<typeof myTask, {
+ *   output: string;
+ * }>('run-id-123');
+ * ```
+ */
+export declare function useRealtimeRunWithStreams<TTask extends AnyTask = AnyTask, TStreams extends Record<string, any> = Record<string, any>>(runId?: string, options?: UseRealtimeRunOptions): UseRealtimeRunWithStreamsInstance<TTask, TStreams>;
+export type UseRealtimeRunsInstance<TTask extends AnyTask = AnyTask> = {
+    runs: RealtimeRun<TTask>[];
+    error: Error | undefined;
+    /**
+     * Abort the current request immediately.
+     */
+    stop: () => void;
+};
+/**
+ * Hook to subscribe to realtime updates of task runs filtered by tag(s).
+ *
+ * @template TTask - The type of the task
+ * @param {string | string[]} tag - The tag or array of tags to filter runs by
+ * @param {UseRealtimeRunOptions} [options] - Configuration options for the subscription
+ * @returns {UseRealtimeRunsInstance<TTask>} An object containing the current state of the runs and any error encountered
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { runs, error } = useRealtimeRunsWithTag<typeof myTask>('my-tag');
+ * // Or with multiple tags
+ * const { runs, error } = useRealtimeRunsWithTag<typeof myTask>(['tag1', 'tag2']);
+ * ```
+ */
+export declare function useRealtimeRunsWithTag<TTask extends AnyTask>(tag: string | string[], options?: UseRealtimeRunOptions): UseRealtimeRunsInstance<TTask>;
+/**
+ * Hook to subscribe to realtime updates of a batch of task runs.
+ *
+ * @template TTask - The type of the task
+ * @param {string} batchId - The unique identifier of the batch to subscribe to
+ * @param {UseRealtimeRunOptions} [options] - Configuration options for the subscription
+ * @returns {UseRealtimeRunsInstance<TTask>} An object containing the current state of the runs, error handling, and control methods
+ *
+ * @example
+ * ```ts
+ * import type { myTask } from './path/to/task';
+ * const { runs, error } = useRealtimeBatch<typeof myTask>('batch-id-123');
+ * ```
+ */
+export declare function useRealtimeBatch<TTask extends AnyTask>(batchId: string, options?: UseRealtimeRunOptions): UseRealtimeRunsInstance<TTask>;