robotrock 0.6.0 → 0.8.0

package/dist/schemas/index.js

@@ -1,24 +1,165 @@
+// src/schemas/index.ts
+import { z } from "zod";
 import {
-  DEFAULT_TASK_PRIORITY,
-  DEFAULT_THREAD_UPDATE_STATUS,
-  LOWEST_TASK_PRIORITY,
-  TASK_PRIORITY_RANK,
-  assignToSchema,
-  createTaskBodySchema,
-  taskContextSchema,
-  taskPriorities,
-  taskPrioritySchema,
-  threadUpdateBodySchema,
-  threadUpdateInputSchema,
-  threadUpdateMessageSchema,
-  threadUpdateStatusSchema,
-  threadUpdateStatuses
-} from "../chunk-TAWMIQAM.js";
+  isPublicHttpUrl,
+  PUBLIC_HTTP_URL_ERROR
+} from "@robotrock/core/utils";
+import { validateContextPublicUrls } from "@robotrock/core/schemas";
+var safeUrlSchema = z.string().refine((url) => isPublicHttpUrl(url), {
+  message: PUBLIC_HTTP_URL_ERROR
+});
+var jsonSchema7Schema = z.custom(
+  (val) => typeof val === "object" && val !== null,
+  { message: "Must be a valid JSON Schema object" }
+);
+var uiSchemaSchema = z.custom((val) => typeof val === "object" && val !== null, {
+  message: "Must be a valid UiSchema object"
+});
+var webhookHandlerSchema = z.object({
+  type: z.literal("webhook"),
+  url: safeUrlSchema,
+  headers: z.record(z.string(), z.string())
+});
+var triggerHandlerSchema = webhookHandlerSchema.extend({
+  type: z.literal("trigger"),
+  tokenId: z.string().min(1)
+});
+var handlerSchema = z.discriminatedUnion("type", [webhookHandlerSchema, triggerHandlerSchema]);
+var taskActionSchema = z.object({
+  id: z.string().min(1),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  schema: jsonSchema7Schema.optional(),
+  ui: uiSchemaSchema.optional(),
+  data: z.record(z.string(), z.unknown()).optional(),
+  handlers: z.array(handlerSchema).min(1).optional()
+});
+var uiFieldSchemaSchema = z.object({
+  "ui:widget": z.string().optional(),
+  "ui:title": z.string().optional(),
+  "ui:description": z.string().optional(),
+  "ui:options": z.record(z.string(), z.unknown()).optional(),
+  items: z.lazy(() => z.record(z.string(), uiFieldSchemaSchema)).optional()
+}).passthrough();
+var contextUiSchema = z.record(z.string(), uiFieldSchemaSchema).optional();
+var contextDataSchema = z.object({
+  data: z.record(z.string(), z.unknown()),
+  ui: contextUiSchema
+}).optional();
+var taskContextObjectSchema = z.object({
+  app: z.string().min(1).optional(),
+  type: z.string().min(1),
+  name: z.string().min(1),
+  description: z.string().optional(),
+  validUntil: z.string().optional(),
+  context: contextDataSchema,
+  version: z.literal(2).optional(),
+  actions: z.array(taskActionSchema).min(1, "At least one action is required")
+});
+function refineContextPublicUrls(data, ctx) {
+  const error = validateContextPublicUrls(data.context);
+  if (error) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: error,
+      path: ["context"]
+    });
+  }
+}
+var taskContextSchema = taskContextObjectSchema.superRefine(
+  refineContextPublicUrls
+);
+var assignToSchema = z.object({
+  users: z.array(z.string().email()).optional(),
+  groups: z.array(z.string().min(1)).optional()
+}).refine(
+  (data) => {
+    const groups = data.groups ?? [];
+    if (groups.includes("all") && groups.length > 1) {
+      return false;
+    }
+    return true;
+  },
+  { message: 'Cannot combine "all" with other group slugs' }
+);
+var threadUpdateMessageSchema = z.string().min(1).max(500);
+var threadUpdateStatuses = [
+  "info",
+  "queued",
+  "running",
+  "waiting",
+  "succeeded",
+  "failed",
+  "cancelled"
+];
+var threadUpdateStatusSchema = z.enum(threadUpdateStatuses);
+var DEFAULT_THREAD_UPDATE_STATUS = "info";
+var threadUpdateInputSchema = z.object({
+  message: threadUpdateMessageSchema,
+  status: threadUpdateStatusSchema.optional()
+});
+var taskPriorities = ["low", "normal", "high", "urgent"];
+var taskPrioritySchema = z.enum(taskPriorities);
+var DEFAULT_TASK_PRIORITY = "normal";
+var LOWEST_TASK_PRIORITY = "low";
+var TASK_PRIORITY_RANK = {
+  low: 1,
+  normal: 2,
+  high: 3,
+  urgent: 4
+};
+var nonNegativeInt = z.number().int().nonnegative();
+var agentCostTokensSchema = z.object({
+  input: nonNegativeInt.optional(),
+  output: nonNegativeInt.optional(),
+  total: nonNegativeInt.optional()
+});
+var agentCostSchema = z.object({
+  tokens: agentCostTokensSchema.optional(),
+  eur: z.number().nonnegative().optional(),
+  usd: z.number().nonnegative().optional()
+});
+var AGENT_INFO_MAX_KEYS = 32;
+var agentTelemetrySchema = z.object({
+  version: z.string().min(1).optional(),
+  toolCallCount: nonNegativeInt.optional(),
+  cost: agentCostSchema.optional(),
+  info: z.record(z.string(), z.unknown()).optional()
+}).refine(
+  (data) => {
+    const keys = data.info ? Object.keys(data.info) : [];
+    return keys.length <= AGENT_INFO_MAX_KEYS;
+  },
+  { message: `agent.info may contain at most ${AGENT_INFO_MAX_KEYS} keys` }
+);
+var createTaskBodySchema = taskContextObjectSchema.extend({
+  assignTo: assignToSchema.optional(),
+  /**
+   * Groups related tasks together. When omitted, the server generates one and
+   * returns it so the caller can reuse it on later tasks in the same thread.
+   */
+  threadId: z.string().min(1).optional(),
+  /**
+   * Optional thread priority. When set, applies to the whole thread and
+   * overwrites any previous priority. Omit on later tasks to leave unchanged.
+   */
+  priority: taskPrioritySchema.optional(),
+  /**
+   * Optional initial status update logged against the task's thread. Shows in
+   * the inbox status bar and the thread update log.
+   */
+  update: threadUpdateInputSchema.optional(),
+  agent: agentTelemetrySchema.optional()
+}).superRefine(refineContextPublicUrls);
+var threadUpdateBodySchema = threadUpdateInputSchema;
 export {
   DEFAULT_TASK_PRIORITY,
   DEFAULT_THREAD_UPDATE_STATUS,
   LOWEST_TASK_PRIORITY,
   TASK_PRIORITY_RANK,
+  agentCostSchema,
+  agentCostTokensSchema,
+  agentTelemetrySchema,
   assignToSchema,
   createTaskBodySchema,
   taskContextSchema,

package/dist/schemas/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../../src/schemas/index.ts"],"sourcesContent":["import { z } from \"zod\";\nimport {\n  isPublicHttpUrl,\n  PUBLIC_HTTP_URL_ERROR,\n} from \"@robotrock/core/utils\";\nimport { validateContextPublicUrls } from \"@robotrock/core/schemas\";\n\nexport interface JSONSchema7 {\n  $id?: string;\n  $ref?: string;\n  $schema?: string;\n  $comment?: string;\n  type?: JSONSchema7TypeName | JSONSchema7TypeName[];\n  enum?: unknown[];\n  const?: unknown;\n  multipleOf?: number;\n  maximum?: number;\n  exclusiveMaximum?: number;\n  minimum?: number;\n  exclusiveMinimum?: number;\n  maxLength?: number;\n  minLength?: number;\n  pattern?: string;\n  format?: string;\n  items?: JSONSchema7 | JSONSchema7[];\n  additionalItems?: JSONSchema7 | boolean;\n  maxItems?: number;\n  minItems?: number;\n  uniqueItems?: boolean;\n  contains?: JSONSchema7;\n  maxProperties?: number;\n  minProperties?: number;\n  required?: string[];\n  properties?: Record<string, JSONSchema7>;\n  patternProperties?: Record<string, JSONSchema7>;\n  additionalProperties?: JSONSchema7 | boolean;\n  dependencies?: Record<string, JSONSchema7 | string[]>;\n  propertyNames?: JSONSchema7;\n  if?: JSONSchema7;\n  then?: JSONSchema7;\n  else?: JSONSchema7;\n  allOf?: JSONSchema7[];\n  anyOf?: JSONSchema7[];\n  oneOf?: JSONSchema7[];\n  not?: JSONSchema7;\n  title?: string;\n  description?: string;\n  default?: unknown;\n  readOnly?: boolean;\n  writeOnly?: boolean;\n  examples?: unknown[];\n}\n\nexport type JSONSchema7TypeName =\n  | \"string\"\n  | \"number\"\n  | \"integer\"\n  | \"boolean\"\n  | \"object\"\n  | \"array\"\n  | \"null\";\n\nexport type ExtendedJSONSchema7 = JSONSchema7 & {\n  enumNames?: string[];\n  [key: string]: unknown;\n};\n\nexport type UiSchema = {\n  \"ui:widget\"?: string;\n  \"ui:title\"?: string;\n  \"ui:description\"?: string;\n  \"ui:placeholder\"?: string;\n  \"ui:options\"?: Record<string, unknown>;\n  [key: string]: unknown;\n};\n\nconst safeUrlSchema = z.string().refine((url) => isPublicHttpUrl(url), {\n  message: PUBLIC_HTTP_URL_ERROR,\n});\n\nconst jsonSchema7Schema = z.custom<ExtendedJSONSchema7>(\n  (val) => typeof val === \"object\" && val !== null,\n  { message: \"Must be a valid JSON Schema object\" }\n);\n\nconst uiSchemaSchema = z.custom<UiSchema>((val) => typeof val === \"object\" && val !== null, {\n  message: \"Must be a valid UiSchema object\",\n});\n\nconst webhookHandlerSchema = z.object({\n  type: z.literal(\"webhook\"),\n  url: safeUrlSchema,\n  headers: z.record(z.string(), z.string()),\n});\n\nconst triggerHandlerSchema = webhookHandlerSchema.extend({\n  type: z.literal(\"trigger\"),\n  tokenId: z.string().min(1),\n});\n\nconst handlerSchema = z.discriminatedUnion(\"type\", [webhookHandlerSchema, triggerHandlerSchema]);\n\nconst taskActionSchema = z.object({\n  id: z.string().min(1),\n  title: z.string().min(1),\n  description: z.string().optional(),\n  schema: jsonSchema7Schema.optional(),\n  ui: uiSchemaSchema.optional(),\n  data: z.record(z.string(), z.unknown()).optional(),\n  handlers: z.array(handlerSchema).min(1).optional(),\n});\n\nconst uiFieldSchemaSchema: z.ZodType<Record<string, unknown>> = z\n  .object({\n    \"ui:widget\": z.string().optional(),\n    \"ui:title\": z.string().optional(),\n    \"ui:description\": z.string().optional(),\n    \"ui:options\": z.record(z.string(), z.unknown()).optional(),\n    items: z.lazy(() => z.record(z.string(), uiFieldSchemaSchema)).optional(),\n  })\n  .passthrough();\n\nconst contextUiSchema = z.record(z.string(), uiFieldSchemaSchema).optional();\n\nconst contextDataSchema = z\n  .object({\n    data: z.record(z.string(), z.unknown()),\n    ui: contextUiSchema,\n  })\n  .optional();\n\nconst taskContextObjectSchema = z.object({\n  app: z.string().min(1).optional(),\n  type: z.string().min(1),\n  name: z.string().min(1),\n  description: z.string().optional(),\n  validUntil: z.string().optional(),\n  context: contextDataSchema,\n  version: z.literal(2).optional(),\n  actions: z.array(taskActionSchema).min(1, \"At least one action is required\"),\n});\n\nfunction refineContextPublicUrls<T extends { context?: z.infer<typeof contextDataSchema> }>(\n  data: T,\n  ctx: z.RefinementCtx\n) {\n  const error = validateContextPublicUrls(data.context);\n  if (error) {\n    ctx.addIssue({\n      code: z.ZodIssueCode.custom,\n      message: error,\n      path: [\"context\"],\n    });\n  }\n}\n\nexport const taskContextSchema = taskContextObjectSchema.superRefine(\n  refineContextPublicUrls\n);\n\n/**\n * Assignment targets at task create (not stored in task context JSON).\n * Unknown user emails are auto-provisioned as assignee memberships (count toward seat limits).\n */\nexport const assignToSchema = z\n  .object({\n    users: z.array(z.string().email()).optional(),\n    groups: z.array(z.string().min(1)).optional(),\n  })\n  .refine(\n    (data) => {\n      const groups = data.groups ?? [];\n      if (groups.includes(\"all\") && groups.length > 1) {\n        return false;\n      }\n      return true;\n    },\n    { message: 'Cannot combine \"all\" with other group slugs' }\n  );\n\n/** A short thread-scoped status update message (1-2 sentences). */\nexport const threadUpdateMessageSchema = z.string().min(1).max(500);\n\n/**\n * Lifecycle status carried by a thread update. Drives the icon and color shown\n * in the inbox status bar. Defaults to `info` when omitted.\n */\nexport const threadUpdateStatuses = [\n  \"info\",\n  \"queued\",\n  \"running\",\n  \"waiting\",\n  \"succeeded\",\n  \"failed\",\n  \"cancelled\",\n] as const;\n\nexport const threadUpdateStatusSchema = z.enum(threadUpdateStatuses);\n\n/** The default status applied when an update omits one. */\nexport const DEFAULT_THREAD_UPDATE_STATUS: ThreadUpdateStatus = \"info\";\n\n/** Shared shape for a thread update (standalone and at task creation). */\nexport const threadUpdateInputSchema = z.object({\n  message: threadUpdateMessageSchema,\n  status: threadUpdateStatusSchema.optional(),\n});\n\n/** Thread priority levels for inbox ordering and display. */\nexport const taskPriorities = [\"low\", \"normal\", \"high\", \"urgent\"] as const;\n\nexport const taskPrioritySchema = z.enum(taskPriorities);\n\nexport type TaskPriority = (typeof taskPriorities)[number];\n\nexport const DEFAULT_TASK_PRIORITY: TaskPriority = \"normal\";\n\nexport const LOWEST_TASK_PRIORITY: TaskPriority = \"low\";\n\nexport const TASK_PRIORITY_RANK: Record<TaskPriority, number> = {\n  low: 1,\n  normal: 2,\n  high: 3,\n  urgent: 4,\n};\n\nconst nonNegativeInt = z.number().int().nonnegative();\n\nexport const agentCostTokensSchema = z.object({\n  input: nonNegativeInt.optional(),\n  output: nonNegativeInt.optional(),\n  total: nonNegativeInt.optional(),\n});\n\nexport const agentCostSchema = z.object({\n  tokens: agentCostTokensSchema.optional(),\n  eur: z.number().nonnegative().optional(),\n  usd: z.number().nonnegative().optional(),\n});\n\nconst AGENT_INFO_MAX_KEYS = 32;\n\nexport const agentTelemetrySchema = z\n  .object({\n    version: z.string().min(1).optional(),\n    toolCallCount: nonNegativeInt.optional(),\n    cost: agentCostSchema.optional(),\n    info: z.record(z.string(), z.unknown()).optional(),\n  })\n  .refine(\n    (data) => {\n      const keys = data.info ? Object.keys(data.info) : [];\n      return keys.length <= AGENT_INFO_MAX_KEYS;\n    },\n    { message: `agent.info may contain at most ${AGENT_INFO_MAX_KEYS} keys` }\n  );\n\nexport const createTaskBodySchema = taskContextObjectSchema\n  .extend({\n    assignTo: assignToSchema.optional(),\n    /**\n     * Groups related tasks together. When omitted, the server generates one and\n     * returns it so the caller can reuse it on later tasks in the same thread.\n     */\n    threadId: z.string().min(1).optional(),\n    /**\n     * Optional thread priority. When set, applies to the whole thread and\n     * overwrites any previous priority. Omit on later tasks to leave unchanged.\n     */\n    priority: taskPrioritySchema.optional(),\n    /**\n     * Optional initial status update logged against the task's thread. Shows in\n     * the inbox status bar and the thread update log.\n     */\n    update: threadUpdateInputSchema.optional(),\n    agent: agentTelemetrySchema.optional(),\n  })\n  .superRefine(refineContextPublicUrls);\n\n/** POST /v1/threads/:threadId/updates body: a standalone thread update. */\nexport const threadUpdateBodySchema = threadUpdateInputSchema;\n\n/** Where a thread update originated. */\nexport type ThreadUpdateSource = \"api\" | \"task_create\" | \"dashboard\";\n\n/** Lifecycle status carried by a thread update. */\nexport type ThreadUpdateStatus = (typeof threadUpdateStatuses)[number];\n\n/** A logged thread update as returned by the API. */\nexport interface ThreadUpdate {\n  id: string;\n  threadId: string;\n  message: string;\n  status: ThreadUpdateStatus;\n  source: ThreadUpdateSource;\n  createdAt: number;\n}\n\nexport type AssignToInput = z.infer<typeof assignToSchema>;\nexport type CreateTaskBodyInput = z.input<typeof createTaskBodySchema>;\nexport type CreateTaskBody = z.output<typeof createTaskBodySchema>;\nexport type ThreadUpdateBodyInput = z.input<typeof threadUpdateBodySchema>;\nexport type ThreadUpdateBody = z.output<typeof threadUpdateBodySchema>;\nexport type ThreadUpdateInput = z.input<typeof threadUpdateInputSchema>;\nexport type TaskContextInput = z.input<typeof taskContextSchema>;\nexport type TaskContextOutput = z.output<typeof taskContextSchema>;\nexport type TaskContext = TaskContextOutput;\nexport type TaskAction = z.infer<typeof taskActionSchema>;\nexport type WebhookHandler = z.infer<typeof webhookHandlerSchema>;\nexport type TriggerHandler = z.infer<typeof triggerHandlerSchema>;\nexport type Handler = z.infer<typeof handlerSchema>;\nexport type AgentCostTokens = z.infer<typeof agentCostTokensSchema>;\nexport type AgentCost = z.infer<typeof agentCostSchema>;\nexport type AgentTelemetry = z.infer<typeof agentTelemetrySchema>;\nexport type AgentTelemetryInput = z.input<typeof agentTelemetrySchema>;\n\ntype InferObjectProperties<\n  Props,\n  Req extends PropertyKey,\n> = Props extends Record<string, unknown>\n  ? ({\n      [K in keyof Props as K extends Req ? K : never]-?: InferJsonSchema7<Props[K]>;\n    } & {\n      [K in keyof Props as K extends Req ? never : K]?: InferJsonSchema7<Props[K]>;\n    } extends infer O\n      ? { [K in keyof O]: O[K] }\n      : never)\n  : Record<string, unknown>;\n\ntype RequiredKeys<S> =\n  S extends { readonly required: readonly string[] } ? S[\"required\"][number] : never;\n\nexport type InferJsonSchema7<S> = [S] extends [undefined]\n  ? Record<string, never>\n  : S extends { readonly const: infer C }\n    ? C\n    : S extends {\n          readonly enum: readonly (infer E)[];\n        }\n      ? E\n      : S extends {\n            readonly type: \"object\";\n            readonly properties?: infer Props;\n          }\n        ? InferObjectProperties<Props, RequiredKeys<S>>\n        : S extends {\n              readonly type: \"object\";\n              readonly properties?: undefined;\n            }\n          ? Record<string, unknown>\n          : S extends {\n                readonly type: \"array\";\n                readonly items?: infer Items;\n              }\n            ? Items extends readonly unknown[]\n              ? InferJsonSchema7<Items[number]>[]\n              : Items extends object\n                ? InferJsonSchema7<Items>[]\n                : unknown[]\n            : S extends { readonly type: \"string\" }\n              ? string\n              : S extends { readonly type: \"number\" } | { readonly type: \"integer\" }\n                ? number\n                : S extends { readonly type: \"boolean\" }\n                  ? boolean\n                  : unknown;\n\nexport type TaskStatus = \"pending\" | \"open\" | \"handled\" | \"expired\";\n\nexport interface TaskResponse {\n  success: boolean;\n  task: {\n    taskId: string;\n    threadId: string;\n    status: \"pending\" | \"open\";\n    context: TaskContext;\n    validUntil: string;\n    submittedAt: string;\n  };\n  message: string;\n}\n\nexport interface ThreadUpdateResponse {\n  success: boolean;\n  update: ThreadUpdate;\n  message: string;\n}\n\nexport interface Task {\n  id: string;\n  threadId?: string;\n  createdAt: Date;\n  status: TaskStatus;\n  context: TaskContext;\n  validUntil: number;\n  handledAt?: number;\n  handled?: {\n    action: {\n      id: string;\n      data: unknown;\n    };\n    handledBy?: string;\n    userId?: string;\n    token?: string;\n  };\n}\n\nexport type InferActionData<T extends { schema?: unknown }> = [\n  Exclude<T[\"schema\"], undefined>,\n] extends [\n  never,\n]\n  ? Record<string, never>\n  : Exclude<T[\"schema\"], undefined> extends infer S\n    ? InferJsonSchema7<S>\n    : Record<string, never>;\n\nexport type TupleElementIndices<T extends readonly unknown[]> = T extends readonly [\n  unknown,\n  ...unknown[],\n]\n  ? Exclude<keyof T, keyof unknown[]>\n  : number;\n\nexport interface TaskResult<T = Record<string, unknown>> {\n  actionId: string;\n  data: T;\n  handledBy?: string;\n  handledAt: Date;\n}\n\nexport interface ApprovalResult<T = Record<string, unknown>> extends TaskResult<T> {\n  taskId: string;\n}\n\nexport type DiscriminatedApprovalResult<\n  TActions extends readonly { id: string; schema?: unknown }[],\n> = {\n  [I in TupleElementIndices<TActions>]: TActions[I] extends { id: string; schema?: unknown }\n    ? Omit<ApprovalResult<InferActionData<TActions[I]>>, \"actionId\" | \"data\"> & {\n        actionId: TActions[I][\"id\"];\n        data: InferActionData<TActions[I]>;\n      }\n    : never\n}[TupleElementIndices<TActions>];\n"],"mappings":"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","names":[]}

package/dist/tool-approval-bridge-BKDY5NAY.d.ts

@@ -0,0 +1,247 @@
+import { z } from 'zod';
+import { R as RobotRock, a as SendToHumanInput, S as SendToHumanActionInput, j as SendUpdateInput } from './client-D-XEBOWd.js';
+import { DiscriminatedApprovalResult, ThreadUpdate } from './schemas/index.js';
+import { ToolApprovalResponse } from 'ai';
+
+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;
+/** 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;
+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>;
+}, z.core.$strip>;
+type ApproveByHumanToolInput = z.infer<typeof approveByHumanInputSchema>;
+type ApproveByHumanToolOptions = {
+    defaultType?: string;
+    description?: string;
+    toolName?: string;
+};
+type ApproveByHumanToolDurableOptions = ApproveByHumanToolOptions & RobotRockAiContext & {
+    mode: "trigger" | "workflow";
+};
+type ApproveByHumanToolDefinition = {
+    description: string;
+    inputSchema: typeof approveByHumanInputSchema;
+    execute: (input: ApproveByHumanToolInput) => Promise<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>>;
+    }, z.core.$strip>>;
+    validUntil: z.ZodOptional<z.ZodString>;
+    assignTo: z.ZodOptional<z.ZodObject<{
+        users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type SendToHumanToolInput = z.infer<typeof sendToHumanToolInputSchema>;
+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";
+};
+type SendToHumanToolDefinition = {
+    description: string;
+    inputSchema: typeof sendToHumanToolInputSchema;
+    execute: (input: SendToHumanToolInput) => Promise<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: "info";
+        queued: "queued";
+        running: "running";
+        waiting: "waiting";
+        succeeded: "succeeded";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>>;
+}, z.core.$strip>;
+type SendUpdateToolInput = z.infer<typeof sendUpdateToolInputSchema>;
+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";
+};
+type SendUpdateToolDefinition = {
+    description: string;
+    inputSchema: typeof sendUpdateToolInputSchema;
+    execute: (input: SendUpdateToolInput) => Promise<SendUpdateToolResult>;
+};
+
+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 { type ApproveByHumanToolDurableOptions as A, createRobotRockAiTriggerContext as B, type CreateSendToHumanToolOptions as C, normalizeRobotRockAiContext as D, sendToHumanForAi as E, type FormatToolApprovalTaskOptions as F, sendToHumanToolInputSchema as G, type HumanToolResult as H, sendUpdateForAi as I, sendUpdateToolInputSchema as J, type RobotRockAiWorkflowContext as R, type SendToHumanToolDefinition as S, type ToolApprovalRequestPart as T, type ApproveByHumanToolOptions as a, type ApproveByHumanToolDefinition as b, type CreateSendUpdateToolOptions as c, type SendUpdateToolDefinition as d, type CreateSendToHumanToolDurableOptions as e, type CreateSendUpdateToolDurableOptions as f, type RobotRockAiContext as g, type RobotRockAiMode as h, type RobotRockAiPollingContext as i, type RobotRockAiTriggerContext as j, applyRobotRockToolApprovalToTools as k, createRobotRockAiWorkflowContext as l, createRobotRockNeedsApproval as m, createRobotRockToolApproval as n, runWithRobotRockApprovals as o, type RobotRockToolCallInfo as p, APPROVE_BY_HUMAN_ACTIONS as q, resolveToolApprovalsViaRobotRock as r, type ResolveToolApprovalsOptions as s, type RobotRockToolApprovalConfig as t, type RobotRockToolApprovalDecision as u, type RunWithRobotRockApprovalsOptions as v, type SendUpdateToolResult as w, approveByHumanForAi as x, approveByHumanInputSchema as y, collectApprovalRequests as z };

package/dist/trigger/index.d.ts

@@ -1,5 +1,5 @@
 import * as _trigger_dev_sdk from '@trigger.dev/sdk';
-import { S as SendToHumanActionInput, a as SendToHumanInput } from '../client-CLcHdjOz.js';
+import { S as SendToHumanActionInput, a as SendToHumanInput } from '../client-D-XEBOWd.js';
 export { R as RobotRockHandlerWebhookPayload } from '../handler-webhook-BqEi6Bk-.js';
 export { ApprovalResult, DiscriminatedApprovalResult, TaskContextInput, TaskResult } from '../schemas/index.js';
 import 'zod';