robotrock 0.6.0 → 0.8.0

package/dist/workflow-CFcRMNhy.d.ts

@@ -1,393 +0,0 @@
-import * as ai from 'ai';
-import { ToolApprovalResponse } from 'ai';
-import { z } from 'zod';
-import { b as RobotRock, a as SendToHumanInput, S as SendToHumanActionInput, l as SendUpdateInput } from './client-CLcHdjOz.js';
-import { DiscriminatedApprovalResult, ThreadUpdate } from './schemas/index.js';
-
-declare const APPROVE_BY_HUMAN_ACTIONS$1: readonly [{
-    readonly id: "approve";
-    readonly title: "Approve";
-}, {
-    readonly id: "decline";
-    readonly title: "Decline";
-}];
-/** How RobotRock waits for a human inside AI SDK tool `execute`. */
-type RobotRockAiMode = "polling" | "trigger" | "workflow";
-/**
- * Polling: `client.sendToHuman()` blocks until handled (scripts, API routes with long timeout).
- * Trigger: `sendToHumanTask.triggerAndWait()` uses wait tokens (Trigger.dev workers).
- * Workflow: `sendToHumanInWorkflow()` uses workflow webhooks (Vercel Workflow).
- */
-type RobotRockAiPollingContext = {
-    mode?: "polling";
-    client: RobotRock;
-};
-type RobotRockAiTriggerContext = {
-    mode: "trigger";
-    /** Inbox app bucket; falls back to `ROBOTROCK_APP` in the Trigger worker. */
-    app?: string;
-};
-type RobotRockAiWorkflowContext = {
-    mode: "workflow";
-    /** Inbox app bucket; falls back to `ROBOTROCK_APP` in the workflow run. */
-    app?: string;
-};
-type RobotRockAiContext = RobotRockAiPollingContext | RobotRockAiTriggerContext | RobotRockAiWorkflowContext;
-declare function normalizeRobotRockAiContext(clientOrContext: RobotRock | RobotRockAiContext): RobotRockAiContext;
-declare function sendToHumanForAi<A extends readonly SendToHumanActionInput[] = readonly SendToHumanActionInput[]>(context: RobotRockAiContext, payload: SendToHumanInput<A>): Promise<DiscriminatedApprovalResult<A>>;
-/**
- * Posts a thread update for an AI tool, routing by execution mode.
- *
- * `sendUpdate` is fire-and-forget (no human wait), so only the workflow path
- * needs durability — it runs inside a `"use step"`. Trigger and polling modes
- * issue the request directly.
- */
-declare function sendUpdateForAi(context: RobotRockAiContext, payload: SendUpdateInput): Promise<ThreadUpdate>;
-declare function approveByHumanForAi(context: RobotRockAiContext, payload: Omit<SendToHumanInput, "actions"> & {
-    app?: string;
-}): Promise<DiscriminatedApprovalResult<typeof APPROVE_BY_HUMAN_ACTIONS$1>>;
-
-type HumanToolResult = {
-    taskId: string;
-    actionId: string;
-    data: unknown;
-    handledBy?: string;
-    handledAt: string;
-    /** Present when action ids are approve/decline (or approve/reject). */
-    approved?: boolean;
-};
-type RobotRockToolCallInfo = {
-    toolName: string;
-    toolCallId: string;
-    input: unknown;
-};
-type RobotRockToolApprovalConfig = {
-    /** Tool names that require RobotRock inbox approval before execution. */
-    tools?: readonly string[];
-    /** Custom predicate when tool names alone are not enough. */
-    when?: (toolCall: RobotRockToolCallInfo) => boolean;
-};
-type FormatToolApprovalTaskOptions = {
-    type?: string;
-    approveActionId?: string;
-    denyActionId?: string;
-};
-type ResolveToolApprovalsOptions = {
-    formatTask?: (toolCall: RobotRockToolCallInfo) => SendToHumanInput;
-    approveActionId?: string;
-    denyActionId?: string;
-};
-type RunWithRobotRockApprovalsOptions<T> = {
-    /** Polling mode (requires `client`). */
-    client?: RobotRock;
-    /** Polling or Trigger mode; use `{ mode: "trigger" }` inside Trigger.dev workers. */
-    context?: RobotRockAiContext;
-    /** Initial messages; updated across approval rounds. */
-    messages?: unknown[];
-    maxRounds?: number;
-    resolveOptions?: ResolveToolApprovalsOptions;
-    generate: (messages: unknown[]) => Promise<T>;
-};
-type ToolApprovalRequestPart = {
-    type: "tool-approval-request";
-    approvalId: string;
-    toolCallId?: string;
-    toolCall?: RobotRockToolCallInfo;
-    isAutomatic?: boolean;
-};
-
-declare const APPROVE_BY_HUMAN_ACTIONS: readonly [{
-    readonly id: "approve";
-    readonly title: "Approve";
-}, {
-    readonly id: "decline";
-    readonly title: "Decline";
-}];
-declare const approveByHumanInputSchema: z.ZodObject<{
-    type: z.ZodOptional<z.ZodString>;
-    name: z.ZodString;
-    description: z.ZodString;
-    contextSummary: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    description: string;
-    name: string;
-    type?: string | undefined;
-    contextSummary?: string | undefined;
-}, {
-    description: string;
-    name: string;
-    type?: string | undefined;
-    contextSummary?: string | undefined;
-}>;
-type ApproveByHumanToolOptions = {
-    defaultType?: string;
-    description?: string;
-    toolName?: string;
-};
-type ApproveByHumanToolDurableOptions = ApproveByHumanToolOptions & RobotRockAiContext & {
-    mode: "trigger" | "workflow";
-};
-/**
- * AI SDK tool with fixed approve/decline actions; blocks until a human decides.
- *
- * - `approveByHumanTool(robotrock)` — polling via `client.sendToHuman()` (default).
- * - `approveByHumanTool({ mode: "trigger", app?: "my-agent" })` — durable wait via Trigger.dev.
- * - `approveByHumanTool({ mode: "workflow", app?: "my-agent" })` — durable wait via Vercel Workflow.
- */
-declare function approveByHumanTool(clientOrContext: RobotRock | ApproveByHumanToolDurableOptions, maybeOptions?: ApproveByHumanToolOptions): ai.Tool<{
-    description: string;
-    name: string;
-    type?: string | undefined;
-    contextSummary?: string | undefined;
-}, HumanToolResult>;
-
-declare const sendToHumanToolInputSchema: z.ZodObject<{
-    type: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    context: z.ZodOptional<z.ZodObject<{
-        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        ui: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, "strip", z.ZodTypeAny, {
-        ui?: Record<string, unknown> | undefined;
-        data?: Record<string, unknown> | undefined;
-    }, {
-        ui?: Record<string, unknown> | undefined;
-        data?: Record<string, unknown> | undefined;
-    }>>;
-    validUntil: z.ZodOptional<z.ZodString>;
-    assignTo: z.ZodOptional<z.ZodEffects<z.ZodObject<{
-        users: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        groups: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        users?: string[] | undefined;
-        groups?: string[] | undefined;
-    }, {
-        users?: string[] | undefined;
-        groups?: string[] | undefined;
-    }>, {
-        users?: string[] | undefined;
-        groups?: string[] | undefined;
-    }, {
-        users?: string[] | undefined;
-        groups?: string[] | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    type: string;
-    name: string;
-    description?: string | undefined;
-    validUntil?: string | undefined;
-    context?: {
-        ui?: Record<string, unknown> | undefined;
-        data?: Record<string, unknown> | undefined;
-    } | undefined;
-    assignTo?: {
-        users?: string[] | undefined;
-        groups?: string[] | undefined;
-    } | undefined;
-}, {
-    type: string;
-    name: string;
-    description?: string | undefined;
-    validUntil?: string | undefined;
-    context?: {
-        ui?: Record<string, unknown> | undefined;
-        data?: Record<string, unknown> | undefined;
-    } | undefined;
-    assignTo?: {
-        users?: string[] | undefined;
-        groups?: string[] | undefined;
-    } | undefined;
-}>;
-type CreateSendToHumanToolOptions<A extends readonly SendToHumanActionInput[] = readonly SendToHumanActionInput[]> = {
-    actions: A;
-    defaultType?: string;
-    description?: string;
-    toolName?: string;
-    /**
-     * Group every task this tool creates onto a shared thread. Pass the same
-     * value to {@link createSendUpdateTool} so updates land on the same thread.
-     */
-    threadId?: string;
-};
-type CreateSendToHumanToolDurableOptions<A extends readonly SendToHumanActionInput[] = readonly SendToHumanActionInput[]> = CreateSendToHumanToolOptions<A> & RobotRockAiContext & {
-    mode: "trigger" | "workflow";
-};
-/**
- * AI SDK tool that blocks until a human handles a RobotRock task with developer-defined actions.
- *
- * - `createSendToHumanTool(robotrock, options)` — polling (default).
- * - `createSendToHumanTool({ mode: "trigger", actions: [...], app?: "my-agent" })` — Trigger.dev wait tokens.
- * - `createSendToHumanTool({ mode: "workflow", actions: [...], app?: "my-agent" })` — Vercel Workflow webhooks.
- */
-declare function createSendToHumanTool<A extends readonly SendToHumanActionInput[] = readonly SendToHumanActionInput[]>(clientOrOptions: RobotRock | CreateSendToHumanToolDurableOptions<A>, maybeOptions?: CreateSendToHumanToolOptions<A>): ai.Tool<{
-    type: string;
-    name: string;
-    description?: string | undefined;
-    validUntil?: string | undefined;
-    context?: {
-        ui?: Record<string, unknown> | undefined;
-        data?: Record<string, unknown> | undefined;
-    } | undefined;
-    assignTo?: {
-        users?: string[] | undefined;
-        groups?: string[] | undefined;
-    } | undefined;
-}, HumanToolResult>;
-
-/**
- * Result returned to the model by {@link createSendUpdateTool}.
- *
- * Updates are fire-and-forget, so a missing thread (no task created yet) is
- * reported as `{ posted: false }` instead of throwing — that way an agent loop
- * is never aborted by a non-critical progress update. Genuine failures (auth,
- * validation, server errors) still throw.
- */
-type SendUpdateToolResult = {
-    posted: true;
-    threadId: string;
-    update: ThreadUpdate;
-} | {
-    posted: false;
-    threadId: string;
-    reason: "thread_not_found";
-    message: string;
-};
-declare const sendUpdateToolInputSchema: z.ZodObject<{
-    threadId: z.ZodOptional<z.ZodString>;
-    message: z.ZodString;
-    status: z.ZodOptional<z.ZodEnum<["info", "queued", "running", "waiting", "succeeded", "failed", "cancelled"]>>;
-}, "strip", z.ZodTypeAny, {
-    message: string;
-    status?: "info" | "queued" | "running" | "waiting" | "succeeded" | "failed" | "cancelled" | undefined;
-    threadId?: string | undefined;
-}, {
-    message: string;
-    status?: "info" | "queued" | "running" | "waiting" | "succeeded" | "failed" | "cancelled" | undefined;
-    threadId?: string | undefined;
-}>;
-type CreateSendUpdateToolOptions = {
-    /**
-     * Session thread to post updates to when the model does not supply `threadId`.
-     * Pass the same value to {@link createSendToHumanTool} to auto-thread tasks
-     * and updates together.
-     */
-    threadId?: string;
-    description?: string;
-};
-type CreateSendUpdateToolDurableOptions = CreateSendUpdateToolOptions & RobotRockAiContext & {
-    mode: "trigger" | "workflow";
-};
-/**
- * AI SDK tool that posts a progress update to a RobotRock thread.
- *
- * Fire-and-forget (no human wait): the agent reports status as it works.
- *
- * - `createSendUpdateTool(robotrock, options?)` — polling client (default).
- * - `createSendUpdateTool({ mode: "trigger", app?: "my-agent" })` — Trigger.dev worker.
- * - `createSendUpdateTool({ mode: "workflow", app?: "my-agent" })` — Vercel Workflow (durable step).
- *
- * The thread is resolved from the tool input `threadId`, falling back to a
- * session `threadId` in the options. Provide at least one.
- */
-declare function createSendUpdateTool(clientOrOptions: RobotRock | CreateSendUpdateToolDurableOptions, maybeOptions?: CreateSendUpdateToolOptions): ai.Tool<{
-    message: string;
-    status?: "info" | "queued" | "running" | "waiting" | "succeeded" | "failed" | "cancelled" | undefined;
-    threadId?: string | undefined;
-}, SendUpdateToolResult>;
-
-type CreateRobotRockAiToolsOptions = {
-    /** @default "polling" when `client` is passed; `"trigger"` or `"workflow"` for durable waits. */
-    mode?: "polling" | "trigger" | "workflow";
-    client?: RobotRock;
-    app?: string;
-    /**
-     * Shared thread for tasks and updates these tools create. Enables the
-     * `sendUpdate` tool to auto-thread onto tasks made by the `sendToHuman` tool.
-     */
-    threadId?: string;
-};
-/**
- * Build AI SDK tools for a given RobotRock execution mode.
- *
- * @example Polling (Next.js route, scripts)
- * ```ts
- * const tools = createRobotRockAiTools({ client: robotrock });
- * ```
- *
- * @example Trigger.dev worker
- * ```ts
- * const tools = createRobotRockAiTools({ mode: "trigger", app: "my-agent" });
- * ```
- *
- * @example Vercel Workflow + DurableAgent
- * ```ts
- * const tools = createRobotRockAiTools({ mode: "workflow", app: "my-agent" });
- * ```
- */
-declare function createRobotRockAiTools(options: CreateRobotRockAiToolsOptions): {
-    context: RobotRockAiContext;
-    approveByHuman: (toolOptions?: ApproveByHumanToolOptions) => ai.Tool<{
-        description: string;
-        name: string;
-        type?: string | undefined;
-        contextSummary?: string | undefined;
-    }, HumanToolResult>;
-    sendToHuman: <A extends readonly SendToHumanActionInput[]>(toolOptions: CreateSendToHumanToolOptions<A>) => ai.Tool<{
-        type: string;
-        name: string;
-        description?: string | undefined;
-        validUntil?: string | undefined;
-        context?: {
-            ui?: Record<string, unknown> | undefined;
-            data?: Record<string, unknown> | undefined;
-        } | undefined;
-        assignTo?: {
-            users?: string[] | undefined;
-            groups?: string[] | undefined;
-        } | undefined;
-    }, HumanToolResult>;
-    sendUpdate: (toolOptions?: CreateSendUpdateToolOptions) => ai.Tool<{
-        message: string;
-        status?: "info" | "queued" | "running" | "waiting" | "succeeded" | "failed" | "cancelled" | undefined;
-        threadId?: string | undefined;
-    }, SendUpdateToolResult>;
-};
-/** Shorthand for `{ mode: "trigger", app }`. */
-declare function createRobotRockAiTriggerContext(options?: Omit<RobotRockAiTriggerContext, "mode">): RobotRockAiContext;
-/** Shorthand for `{ mode: "workflow", app }`. */
-declare function createRobotRockAiWorkflowContext(options?: Omit<RobotRockAiWorkflowContext, "mode">): RobotRockAiContext;
-
-type RobotRockToolApprovalDecision = "user-approval" | undefined;
-/**
- * AI SDK 7+: pass the return value to `toolApproval` on `generateText`, `streamText`, or `ToolLoopAgent`.
- * Returns `'user-approval'` for configured tools so execution pauses until a human responds via RobotRock.
- */
-declare function createRobotRockToolApproval(config: RobotRockToolApprovalConfig): (options: {
-    toolCall: RobotRockToolCallInfo;
-}) => Promise<RobotRockToolApprovalDecision>;
-/**
- * AI SDK 5–6: use as `needsApproval` on tool definitions (or via {@link applyRobotRockToolApprovalToTools}).
- */
-declare function createRobotRockNeedsApproval(config: RobotRockToolApprovalConfig): (_input: unknown, options: {
-    toolCallId: string;
-    messages?: unknown[];
-}) => Promise<boolean>;
-/**
- * AI SDK 5–6: merge `needsApproval` into each matching tool in a tools object.
- */
-declare function applyRobotRockToolApprovalToTools<T extends Record<string, object>>(tools: T, config: RobotRockToolApprovalConfig): T;
-declare function collectApprovalRequests(source: unknown): ToolApprovalRequestPart[];
-/**
- * Create RobotRock tasks for pending AI SDK tool approvals and return `tool-approval-response` parts.
- */
-declare function resolveToolApprovalsViaRobotRock(clientOrContext: RobotRock | RobotRockAiContext, source: unknown, options?: ResolveToolApprovalsOptions): Promise<{
-    responses: ToolApprovalResponse[];
-    messages: unknown[];
-}>;
-/**
- * Run `generate` in a loop until manual tool approvals are resolved via RobotRock or `maxRounds` is reached.
- */
-declare function runWithRobotRockApprovals<T>(options: RunWithRobotRockApprovalsOptions<T>): Promise<T>;
-
-export { APPROVE_BY_HUMAN_ACTIONS as A, createRobotRockNeedsApproval as B, type CreateSendToHumanToolOptions as C, createRobotRockToolApproval as D, resolveToolApprovalsViaRobotRock as E, type FormatToolApprovalTaskOptions as F, runWithRobotRockApprovals as G, type HumanToolResult as H, type RobotRockToolApprovalDecision as I, type ResolveToolApprovalsOptions as J, type RobotRockToolApprovalConfig as K, type RunWithRobotRockApprovalsOptions as L, type RobotRockToolCallInfo as R, type SendUpdateToolResult as S, type ToolApprovalRequestPart as T, approveByHumanTool as a, approveByHumanInputSchema as b, type ApproveByHumanToolOptions as c, type ApproveByHumanToolDurableOptions as d, createSendToHumanTool as e, type CreateSendToHumanToolDurableOptions as f, createSendUpdateTool as g, sendUpdateToolInputSchema as h, type CreateSendUpdateToolOptions as i, type CreateSendUpdateToolDurableOptions as j, approveByHumanForAi as k, sendToHumanForAi as l, sendUpdateForAi as m, normalizeRobotRockAiContext as n, type RobotRockAiContext as o, type RobotRockAiMode as p, type RobotRockAiPollingContext as q, type RobotRockAiTriggerContext as r, sendToHumanToolInputSchema as s, type RobotRockAiWorkflowContext as t, createRobotRockAiTools as u, createRobotRockAiTriggerContext as v, createRobotRockAiWorkflowContext as w, type CreateRobotRockAiToolsOptions as x, applyRobotRockToolApprovalToTools as y, collectApprovalRequests as z };