experimental-ash 0.22.1 → 0.23.0

package/dist/src/client/session.js

@@ -185,6 +185,9 @@ function createHandleMessageBody(input) {
     if (input.input.inputResponses !== undefined && input.input.inputResponses.length > 0) {
         body.inputResponses = input.input.inputResponses;
     }
+    if (input.input.clientContext !== undefined) {
+        body.clientContext = input.input.clientContext;
+    }
     if (input.session.continuationToken !== undefined) {
         body.continuationToken = input.session.continuationToken;
     }
@@ -194,6 +197,11 @@ function createHandleMessageBody(input) {
     if (input.session.continuationToken === undefined && body.message === undefined) {
         return null;
     }
+    if (input.session.continuationToken !== undefined &&
+        body.message === undefined &&
+        body.inputResponses === undefined) {
+        return null;
+    }
     if ("continuationToken" in body && Object.keys(body).length === 1) {
         return null;
     }

package/dist/src/client/types.d.ts

@@ -1,5 +1,7 @@
+import type { UserContent } from "ai";
 import type { HandleMessageStreamEvent } from "#protocol/message.js";
 import type { InputResponse } from "#runtime/input/types.js";
+import type { JsonObject } from "#shared/json.js";
 /**
  * Static credential value or per-request credential resolver.
  */
@@ -66,6 +68,15 @@ export interface SendMessageOptions {
  * Input payload for {@link Session.send}.
  */
 export interface SendTurnInput {
+    /**
+     * Ephemeral client/page context for the next model call only.
+     *
+     * Strings are rendered as user-role model context messages. Objects are
+     * JSON-serialized into one user-role model context message. Client context
+     * piggybacks on a message or HITL response; it does not dispatch a turn by
+     * itself and is never persisted to durable session history.
+     */
+    readonly clientContext?: string | readonly string[] | JsonObject;
     /**
      * HITL responses resolving pending approvals or questions.
      */
@@ -73,7 +84,7 @@ export interface SendTurnInput {
     /**
      * Optional follow-up user message for the same turn.
      */
-    readonly message?: string;
+    readonly message?: string | UserContent;
 }
 /**
  * Options for {@link ClientSession.openStream}.

package/dist/src/compiled/.vendor-stamp.json

@@ -20,5 +20,5 @@
     "zod": "4.4.3",
     "zod-validation-error": "5.0.0"
   },
-  "scriptHash": "37a45d2f6d74a5883f9d3788b6389044089cb0cc2b4ec6a62d4cd4fada121dab"
+  "scriptHash": "7fbc085b9ab020af451fc7dfbdd8ae8c5e8eca101bf5c39cc9edb2d63d7231db"
 }

package/dist/src/compiled/@workflow/core/_ms.d.ts

@@ -0,0 +1,4 @@
+// Auto-generated stub for `ms` types referenced by a vendored .d.ts.
+// Emitted by scripts/vendor-compiled/@workflow/core.mjs.
+
+export type StringValue = string;

package/dist/src/compiled/@workflow/core/_workflow-serde.d.ts

@@ -0,0 +1,5 @@
+// Auto-generated stub for `@workflow/serde` symbols referenced by a vendored .d.ts.
+// Emitted by createDeclarationCopier > buildUniqueSymbolStub.
+
+export declare const WORKFLOW_DESERIALIZE: unique symbol;
+export declare const WORKFLOW_SERIALIZE: unique symbol;

package/dist/src/compiled/@workflow/core/_workflow-utils.d.ts

@@ -0,0 +1,8 @@
+// Auto-generated stub for `@workflow/utils` types referenced by a vendored .d.ts.
+// Emitted by scripts/vendor-compiled/@workflow/core.mjs.
+
+export interface PromiseWithResolvers<T = unknown> {
+  promise: Promise<T>;
+  resolve(value: T | PromiseLike<T>): void;
+  reject(reason?: unknown): void;
+}

package/dist/src/compiled/@workflow/core/_workflow-world.d.ts

@@ -0,0 +1,59 @@
+// Auto-generated stub for `@workflow/world` types referenced by a vendored .d.ts.
+// Emitted by scripts/vendor-compiled/@workflow/core.mjs.
+
+type JsonishRecord = Record<string, any>;
+type PaginatedResponse<T> = { cursor?: string | null; data: T[]; hasMore?: boolean };
+
+export interface Event extends JsonishRecord {
+  correlationId?: string | null;
+  eventType?: string;
+}
+export type HealthCheckPayload = JsonishRecord;
+export interface Hook extends JsonishRecord {
+  hookId: string;
+  token: string;
+}
+export type ValidQueueName = string;
+export interface WorkflowRun extends JsonishRecord {
+  runId: string;
+  status: WorkflowRunStatus;
+}
+export type WorkflowRunStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
+export interface World {
+  specVersion?: number;
+  createQueueHandler?: any;
+  queue(...args: any[]): Promise<void>;
+  runs: {
+    get(id: string, params?: JsonishRecord): Promise<WorkflowRun>;
+    list(params?: JsonishRecord): Promise<PaginatedResponse<WorkflowRun>>;
+  };
+  steps: {
+    get(runId: string, stepId: string, params?: JsonishRecord): Promise<any>;
+    list(params: JsonishRecord): Promise<PaginatedResponse<any>>;
+  };
+  events: {
+    create(...args: any[]): Promise<any>;
+    get(runId: string, eventId: string, params?: JsonishRecord): Promise<Event>;
+    list(params: JsonishRecord): Promise<PaginatedResponse<Event>>;
+    listByCorrelationId(params: JsonishRecord): Promise<PaginatedResponse<Event>>;
+  };
+  hooks: {
+    get(hookId: string, params?: JsonishRecord): Promise<Hook>;
+    getByToken(token: string, params?: JsonishRecord): Promise<Hook>;
+    list(params: JsonishRecord): Promise<PaginatedResponse<Hook>>;
+  };
+  streams: {
+    write(runId: string, name: string, chunk: string | Uint8Array): Promise<void>;
+    writeMulti?(runId: string, name: string, chunks: (string | Uint8Array)[]): Promise<void>;
+    close(runId: string, name: string): Promise<void>;
+    get(runId: string, name: string, startIndex?: number): Promise<ReadableStream<Uint8Array>>;
+    list(runId: string): Promise<string[]>;
+    getChunks(runId: string, name: string, options?: JsonishRecord): Promise<any>;
+    getInfo(runId: string, name: string): Promise<any>;
+  };
+  getEncryptionKeyForRun?(run: WorkflowRun): Promise<Uint8Array | undefined>;
+  getEncryptionKeyForRun?(runId: string, context?: JsonishRecord): Promise<Uint8Array | undefined>;
+  resolveLatestDeploymentId?(): Promise<string>;
+  start?(): Promise<void>;
+  close?(): Promise<void>;
+}

package/dist/src/compiled/@workflow/core/capabilities.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Capabilities table for workflow runs based on their `@workflow/core` version.
+ *
+ * When resuming a hook or webhook, the payload must be encoded in a format
+ * that the *target* workflow run's deployment can decode. This module provides
+ * a way to look up what serialization formats a given `@workflow/core` version
+ * supports, so that newer deployments can avoid encoding payloads in formats
+ * that older deployments don't understand (e.g., the `encr` encryption format).
+ *
+ * ## Adding a new format
+ *
+ * When a new serialization format is introduced:
+ * 1. Add the format constant to `SerializationFormat` in `serialization.ts`
+ * 2. Add an entry to `FORMAT_VERSION_TABLE` below with the minimum
+ *    `@workflow/core` version that supports it
+ * 3. The `getRunCapabilities()` function will automatically include it
+ *
+ * ## History
+ *
+ * - `encr` (AES-256-GCM encryption): added in `4.2.0-beta.64`
+ *   Commit: 7618ac36 "Wire AES-GCM encryption into serialization layer (#1251)"
+ *   https://github.com/vercel/workflow/commit/7618ac36
+ */
+import { type SerializationFormatType } from './serialization.js';
+/**
+ * Capabilities of a workflow run based on its `@workflow/core` version.
+ */
+export interface RunCapabilities {
+    /**
+     * The set of serialization format prefixes that the target run can decode.
+     * Use `supportedFormats.has(SerializationFormat.ENCRYPTED)` to check
+     * if encryption is supported, etc.
+     */
+    supportedFormats: ReadonlySet<SerializationFormatType>;
+}
+/**
+ * Look up what serialization capabilities a workflow run supports based on
+ * its `@workflow/core` version string (from `executionContext.workflowCoreVersion`).
+ *
+ * When the version is `undefined`, not a string, or not a valid semver string
+ * (e.g. very old runs that predate the field, or corrupted metadata),
+ * we assume the most conservative capabilities (baseline formats only).
+ */
+export declare function getRunCapabilities(workflowCoreVersion: string | undefined): RunCapabilities;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/src/compiled/@workflow/core/capture-stack.d.ts

@@ -0,0 +1,16 @@
+/**
+ * V8-only (Node, Bun, Chrome, Deno). Rewrites `err.stack` so the top frame is
+ * the caller of `stackStartFn` instead of the framework function that threw.
+ * Without this, terminal overlays (Next.js, Turbopack, VS Code) render the
+ * code frame at our `throw` site inside `@workflow/core`, which is useless
+ * to the user.
+ *
+ * No-op on engines that don't expose `Error.captureStackTrace` — the stack
+ * degrades gracefully to the default behavior.
+ *
+ * Kept in its own tiny module so callers that can't participate in the
+ * `context-errors.ts` ↔ `workflow/get-workflow-metadata.ts` import cycle can
+ * still pull in the helper without pulling in the full error classes.
+ */
+export declare function redirectStackToCaller(err: Error, stackStartFn: Function): void;
+//# sourceMappingURL=capture-stack.d.ts.map

package/dist/src/compiled/@workflow/core/class-serialization.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Class serialization utilities.
+ *
+ * This module is separate from private.ts to avoid pulling in Node.js-only
+ * dependencies (like async_hooks via get-closure-vars.ts) when used in
+ * workflow bundles.
+ */
+/**
+ * Register a class constructor for serialization.
+ * This allows class constructors to be deserialized by looking up the classId.
+ *
+ * Note: The SWC plugin now inlines equivalent registration logic as a
+ * self-contained IIFE (using the same globalThis Symbol-keyed registry),
+ * so this function is no longer imported by generated code. It is retained
+ * for programmatic use and testing.
+ *
+ * Also sets the `classId` property on the class so the serializer can find it
+ * when serializing instances (e.g., step return values).
+ */
+export declare function registerSerializationClass(classId: string, cls: Function): void;
+/**
+ * Find a registered class constructor by ID (used during deserialization)
+ *
+ * @param classId - The class ID to look up
+ * @param global - The global object to check. This ensures workflow code running
+ *                 in a VM only accesses classes registered on the VM's global,
+ *                 matching production serverless behavior where workflow code
+ *                 runs in isolation.
+ */
+export declare function getSerializationClass(classId: string, global: Record<string, any>): Function | undefined;
+//# sourceMappingURL=class-serialization.d.ts.map

package/dist/src/compiled/@workflow/core/classify-error.d.ts

@@ -0,0 +1,19 @@
+import { type RunErrorCode } from '#compiled/@workflow/errors/index.js';
+/**
+ * Classify an error that caused a workflow run to fail.
+ *
+ * After the structural separation of infrastructure vs user code error
+ * handling, the only errors that reach the `run_failed` try/catch are:
+ * - User code errors (throws from workflow functions, propagated step failures)
+ * - WorkflowRuntimeError and subclasses (corrupted event log, missing
+ *   timestamps, workflow/step not registered, etc.)
+ *
+ * Uses each subclass's `.is()` static (a name-based duck check) instead of
+ * a single `instanceof` check because workflows execute in a separate
+ * `vm` realm: the VM-context `WorkflowRuntimeError` and the host-context
+ * one are distinct classes, so `instanceof` returns `false` for any error
+ * thrown inside the workflow VM and we'd misclassify genuine runtime
+ * errors as user errors.
+ */
+export declare function classifyRunError(err: unknown): RunErrorCode;
+//# sourceMappingURL=classify-error.d.ts.map

package/dist/src/compiled/@workflow/core/context-errors.d.ts

@@ -0,0 +1,27 @@
+import { ContextViolationError, type DocsUrl, NotInStepContextError, NotInWorkflowContextError, NotInWorkflowOrStepContextError } from './context-violation-error.js';
+export { ContextViolationError, NotInStepContextError, NotInWorkflowContextError, NotInWorkflowOrStepContextError, };
+/**
+ * Thrown when an API that MUST NOT run inside a workflow function is called
+ * from one (e.g. `resumeHook()`, which would cause determinism issues).
+ * The message names the specific workflow that made the offending call.
+ */
+export declare class UnavailableInWorkflowContextError extends ContextViolationError {
+    name: string;
+    constructor(functionName: string, docsUrl: DocsUrl);
+}
+/**
+ * Throw a {@link NotInWorkflowContextError} whose stack trace points at the
+ * user code that called `stackStartFn`, not at our framework internals.
+ *
+ * Prefer this over `throw new NotInWorkflowContextError(...)` so tooling
+ * (Next.js error overlay, VS Code terminal linkifier, Sentry, etc.) shows
+ * the user's call site as the relevant frame.
+ */
+export declare function throwNotInWorkflowContext(functionName: string, docsUrl: DocsUrl, stackStartFn: Function): never;
+/** See {@link throwNotInWorkflowContext}. */
+export declare function throwNotInStepContext(functionName: string, docsUrl: DocsUrl, stackStartFn: Function): never;
+/** See {@link throwNotInWorkflowContext}. */
+export declare function throwNotInWorkflowOrStepContext(functionName: string, docsUrl: DocsUrl, stackStartFn: Function): never;
+/** See {@link throwNotInWorkflowContext}. */
+export declare function throwUnavailableInWorkflowContext(functionName: string, docsUrl: DocsUrl, stackStartFn: Function): never;
+//# sourceMappingURL=context-errors.d.ts.map

package/dist/src/compiled/@workflow/core/context-violation-error.d.ts

@@ -0,0 +1,97 @@
+/**
+ * A `docs:` line URL. The leading protocol is part of the type so call sites
+ * can't accidentally pass a protocol-relative or bare path.
+ */
+export type DocsUrl = `https://${string}`;
+declare const INSPECT_CUSTOM: unique symbol;
+/**
+ * Structured data for a framed error. The base class takes this and renders
+ * it to plain text (for `.message` / `.stack` / structured logs) or to an
+ * ANSI-framed string (for terminal display via `util.inspect` / `toString`).
+ *
+ * Keeping the pieces structured means we never have to strip ANSI back out
+ * once it's in the message — we just don't put it there in the first place.
+ */
+export interface FramedContent {
+    /** Headline. `{ code: 'foo()' }` segments render as backticked inline code. */
+    readonly title: readonly Segment[];
+    /** One framed branch per entry. The last uses `╰▶`, others use `├▶`. */
+    readonly details: readonly Detail[];
+}
+export type Segment = {
+    readonly text: string;
+} | {
+    readonly code: string;
+} | {
+    readonly dim: string;
+};
+export type Detail = {
+    readonly type: 'plain';
+    readonly segments: readonly Segment[];
+} | {
+    readonly type: 'docs';
+    readonly url: DocsUrl;
+};
+export declare function renderPlain(c: FramedContent): string;
+export declare function renderPretty(c: FramedContent): string;
+/**
+ * Base class for structured context-violation errors.
+ *
+ * Design notes:
+ *
+ * - `.message` is **plain text** (no ANSI escape bytes). Structured logs,
+ *   log drains, CBOR-serialized event data, and anything else that reads
+ *   `err.message` / `err.stack` as a string gets clean output — no mojibake
+ *   in JSON, no `\x1B[...m` noise in Vercel logs.
+ *
+ * - The ANSI-framed version is rendered **lazily** via `toString()` and
+ *   `[util.inspect.custom]`. When the error is thrown and Node prints it
+ *   via `util.inspect`, the user sees the colored, framed box. When it's
+ *   attached to a structured log field, the consumer sees plain text.
+ *
+ * - `fatal = true` marks these as non-retryable. Calling `createHook()`
+ *   from a step function will never succeed no matter how many retries —
+ *   burning attempts just produces duplicated log output. The runtime's
+ *   `FatalError.is(err)` gate recognizes any error with `fatal: true`.
+ */
+export declare abstract class ContextViolationError extends Error {
+    #private;
+    /** Non-retryable — see class doc. */
+    readonly fatal = true;
+    constructor(content: FramedContent);
+    /**
+     * `console.log(err)` and most Node internals route through `util.inspect`,
+     * which respects this symbol. Returning a custom string here means the
+     * thrown error prints as a pretty frame in the terminal while `.message`
+     * and `.stack` stay plain.
+     */
+    [INSPECT_CUSTOM](): string;
+    toString(): string;
+}
+/**
+ * Thrown when an API that must run inside a workflow function is called
+ * from outside a workflow context (e.g. from a step function or from
+ * regular application code).
+ */
+export declare class NotInWorkflowContextError extends ContextViolationError {
+    name: string;
+    constructor(functionName: string, docsUrl: DocsUrl);
+}
+/**
+ * Thrown when an API that must run inside a step function is called from
+ * outside a step context.
+ */
+export declare class NotInStepContextError extends ContextViolationError {
+    name: string;
+    constructor(functionName: string, docsUrl: DocsUrl);
+}
+/**
+ * Thrown when an API that must run inside either a workflow or step function
+ * is called from regular application code.
+ */
+export declare class NotInWorkflowOrStepContextError extends ContextViolationError {
+    name: string;
+    constructor(functionName: string, docsUrl: DocsUrl);
+}
+export {};
+//# sourceMappingURL=context-violation-error.d.ts.map

package/dist/src/compiled/@workflow/core/create-hook.d.ts

@@ -0,0 +1,179 @@
+import type { Serializable } from './schemas.js';
+/**
+ * An object that can be awaited to receive a value.
+ */
+interface Thenable<T> {
+    then: Promise<T>['then'];
+}
+/**
+ * A `Request` that can be responded to within a workflow
+ * step function by calling the `respondWith()` method.
+ */
+export interface RequestWithResponse extends Request {
+    respondWith: (response: Response) => Promise<void>;
+}
+/**
+ * A hook that can be awaited and/or iterated over to receive
+ * a value within a workflow from an external system.
+ *
+ * Hooks implement the TC39 Explicit Resource Management proposal,
+ * allowing them to be used with the `using` keyword for automatic disposal.
+ */
+export interface Hook<T = any> extends AsyncIterable<T>, Thenable<T> {
+    /**
+     * The token used to identify this hook.
+     */
+    token: string;
+    /**
+     * Disposes the hook, releasing its token for reuse by other workflows.
+     *
+     * After calling `dispose()`, the hook will no longer receive any events.
+     * This is useful when you want to explicitly release a hook token before
+     * the workflow completes, allowing another workflow to register a hook
+     * with the same token.
+     *
+     * @example
+     * ```ts
+     * const hook = createHook<{ message: string }>({ token: 'my-token' });
+     *
+     * for await (const payload of hook) {
+     *   if (payload.message === 'done') {
+     *     hook.dispose(); // Release the token early
+     *     break;
+     *   }
+     * }
+     * ```
+     */
+    dispose(): void;
+    /**
+     * Implements the TC39 Explicit Resource Management proposal.
+     * Called automatically when using the `using` keyword.
+     *
+     * @example
+     * ```ts
+     * {
+     *   using hook = createHook<{ message: string }>({ token: 'my-token' });
+     *   const payload = await hook;
+     *   // hook is automatically disposed when the block exits
+     * }
+     * ```
+     */
+    [Symbol.dispose](): void;
+}
+/**
+ * A webhook that can be used to suspend and resume the workflow run
+ * upon receiving an HTTP request to the specified URL.
+ *
+ * @see {@link createWebhook}
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Request
+ */
+export interface Webhook<T extends Request> extends Hook<T> {
+    /**
+     * The URL that external systems can call to send data to the workflow.
+     */
+    url: string;
+}
+export interface HookOptions {
+    /**
+     * Unique token that is used to associate with the hook.
+     *
+     * When specifying an explicit token, the token should be constructed
+     * with information that the dispatching side can reliably reconstruct
+     * the token with the information it has available.
+     *
+     * Deterministic tokens are intended for use with `createHook()` and
+     * server-side `resumeHook()` only. For webhooks (`createWebhook()`),
+     * tokens are always randomly generated to prevent unauthorized access
+     * to the public webhook endpoint.
+     *
+     * If not provided, a randomly generated token will be assigned.
+     *
+     * @example
+     *
+     * ```ts
+     * // Explicit token for a Slack bot (one workflow run per channel)
+     * const hook = createHook<SlackMessage>({
+     *   token: `slack_webhook:${channelId}`,
+     * });
+     * ```
+     */
+    token?: string;
+    /**
+     * Additional user-defined data to include with the hook payload.
+     *
+     * @example
+     *
+     * ```ts
+     * const hook = createHook<{ name: string }>({
+     *   metadata: {
+     *     type: "cat",
+     *     color: "orange",
+     *   },
+     * });
+     * ```
+     */
+    metadata?: Serializable;
+    /**
+     * Whether this hook can be resumed via the public webhook endpoint.
+     *
+     * When `true`, the hook can be triggered by sending an HTTP request to the
+     * public `/.well-known/workflow/v1/webhook/{token}` URL. This is automatically
+     * set when using `createWebhook()`.
+     *
+     * When `false` (the default), the hook can only be resumed server-side
+     * via `resumeHook()`.
+     *
+     * @default false
+     */
+    isWebhook?: boolean;
+}
+export interface WebhookOptions extends Omit<HookOptions, 'token' | 'isWebhook'> {
+    /**
+     * If set to a `Response` object, the webhook will automatically
+     * respond with the specified response.
+     *
+     * If set to `"manual"`, each individual request will need to
+     * be responded to manually from within the workflow by calling the
+     * `respondWith()` method.
+     *
+     * If not set then the webhook will automatically respond with
+     * a `202 Accepted` response.
+     */
+    respondWith?: Response | 'manual';
+}
+/**
+ * Creates a {@link Hook} that can be used to suspend and resume the workflow run with a payload.
+ *
+ * Hooks allow external systems to send arbitrary serializable data into a workflow.
+ *
+ * @param options - Configuration options for the hook.
+ * @returns A `Hook` that can be awaited to receive one or more payloads.
+ *
+ * @example
+ *
+ * ```ts
+ * export async function workflowWithHook() {
+ *   "use workflow";
+ *
+ *   const hook = createHook<{ message: string }>();
+ *   console.log('Hook token:', hook.token);
+ *
+ *   const payload = await hook;
+ *   console.log('Received:', payload.message);
+ * }
+ * ```
+ */
+export declare function createHook<T = any>(options?: HookOptions): Hook<T>;
+/**
+ * Creates a {@link Webhook} that can be used to suspend and resume the workflow
+ * run upon receiving an HTTP request to the specified URL.
+ *
+ * Webhooks will result in a {@link https://developer.mozilla.org/en-US/docs/Web/API/Request | Request} object
+ * that can be interacted with in workflow functions.
+ */
+export declare function createWebhook(options: WebhookOptions & {
+    respondWith: 'manual';
+}): Webhook<RequestWithResponse>;
+export declare function createWebhook(options?: WebhookOptions): Webhook<Request>;
+export {};
+//# sourceMappingURL=create-hook.d.ts.map

package/dist/src/compiled/@workflow/core/define-hook.d.ts

@@ -0,0 +1,68 @@
+import type { StandardSchemaV1 } from '#compiled/@standard-schema/spec/index.js';
+import type { Hook as HookEntity } from './_workflow-world.js';
+import type { Hook, HookOptions } from './create-hook.js';
+/**
+ * A typed hook interface for type-safe hook creation and resumption.
+ */
+export interface TypedHook<TInput, TOutput> {
+    /**
+     * Creates a new hook with the defined output type.
+     *
+     * Note: This method is not available in runtime bundles. Use it from workflow contexts only.
+     *
+     * @param options - Optional hook configuration
+     * @returns A Hook that resolves to the defined output type
+     */
+    create(options?: HookOptions): Hook<TOutput>;
+    /**
+     * Resumes a hook by sending a payload with the defined input type.
+     * This is a type-safe wrapper around the `resumeHook` runtime function.
+     *
+     * @param token - The unique token identifying the hook
+     * @param payload - The payload to send; if a `schema` is configured it is validated/transformed before resuming
+     * @returns Promise resolving to the hook entity
+     * @throws Error if the hook is not found or if there's an error during the process
+     */
+    resume(token: string, payload: TInput): Promise<HookEntity>;
+}
+export declare namespace TypedHook {
+    /**
+     * Extracts the input type from a {@link TypedHook}
+     */
+    type Input<T extends TypedHook<any, any>> = T extends TypedHook<infer I, any> ? I : never;
+}
+/**
+ * Defines a typed hook for type-safe hook creation and resumption.
+ *
+ * This helper provides type safety by allowing you to define the input and output types
+ * for the hook's payload, with optional validation and transformation via a schema.
+ *
+ * @param schema - Schema used to validate and transform the input payload before resuming
+ * @returns An object with `create` and `resume` functions pre-typed with the input and output types
+ *
+ * @example
+ *
+ * ```ts
+ * // Define a hook with a specific payload type
+ * const approvalHook = defineHook<{ approved: boolean; comment: string }>();
+ *
+ * // In a workflow
+ * export async function workflowWithApproval() {
+ *   "use workflow";
+ *
+ *   const hook = approvalHook.create();
+ *   const result = await hook; // Fully typed as { approved: boolean; comment: string; }
+ * }
+ *
+ * // In an API route
+ * export async function POST(request: Request) {
+ *   const { token, approved, comment } = await request.json();
+ *   await approvalHook.resume(token, { approved, comment }); // Input type
+ *   return Response.json({ success: true });
+ * }
+ * ```
+ */
+export declare function defineHook<TInput, TOutput = TInput>({ schema, }?: {
+    schema?: StandardSchemaV1<TInput, TOutput>;
+}): TypedHook<TInput, TOutput>;
+//# sourceMappingURL=define-hook.d.ts.map