robotrock 0.7.0 → 0.8.1

package/dist/ai/trigger.js

@@ -1,17 +1,1453 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+
+// src/schemas/index.ts
+import { z } from "zod";
 import {
-  applyRobotRockToolApprovalToTools,
-  approveByHumanTool,
-  createRobotRockAiTools,
-  createRobotRockAiTriggerContext,
-  createRobotRockNeedsApproval,
-  createRobotRockToolApproval,
-  createSendToHumanTool,
-  createSendUpdateTool,
-  resolveToolApprovalsViaRobotRock,
-  runWithRobotRockApprovals
-} from "../chunk-55JHCNYX.js";
-import "../chunk-ZG2XVK6Y.js";
-import "../chunk-ZHASQUX6.js";
+  isPublicHttpUrl,
+  PUBLIC_HTTP_URL_ERROR
+} from "@robotrock/core/utils";
+import { validateContextPublicUrls } from "@robotrock/core/schemas";
+function refineContextPublicUrls(data, ctx) {
+  const error = validateContextPublicUrls(data.context);
+  if (error) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: error,
+      path: ["context"]
+    });
+  }
+}
+var safeUrlSchema, jsonSchema7Schema, uiSchemaSchema, webhookHandlerSchema, triggerHandlerSchema, handlerSchema, taskActionSchema, uiFieldSchemaSchema, contextUiSchema, contextDataSchema, taskContextObjectSchema, taskContextSchema, assignToSchema, threadUpdateMessageSchema, threadUpdateStatuses, threadUpdateStatusSchema, threadUpdateInputSchema, taskPriorities, taskPrioritySchema, nonNegativeInt, agentCostTokensSchema, agentCostSchema, AGENT_INFO_MAX_KEYS, agentTelemetrySchema, createTaskBodySchema, threadUpdateBodySchema;
+var init_schemas = __esm({
+  "src/schemas/index.ts"() {
+    "use strict";
+    safeUrlSchema = z.string().refine((url) => isPublicHttpUrl(url), {
+      message: PUBLIC_HTTP_URL_ERROR
+    });
+    jsonSchema7Schema = z.custom(
+      (val) => typeof val === "object" && val !== null,
+      { message: "Must be a valid JSON Schema object" }
+    );
+    uiSchemaSchema = z.custom((val) => typeof val === "object" && val !== null, {
+      message: "Must be a valid UiSchema object"
+    });
+    webhookHandlerSchema = z.object({
+      type: z.literal("webhook"),
+      url: safeUrlSchema,
+      headers: z.record(z.string(), z.string())
+    });
+    triggerHandlerSchema = webhookHandlerSchema.extend({
+      type: z.literal("trigger"),
+      tokenId: z.string().min(1)
+    });
+    handlerSchema = z.discriminatedUnion("type", [webhookHandlerSchema, triggerHandlerSchema]);
+    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()
+    });
+    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();
+    contextUiSchema = z.record(z.string(), uiFieldSchemaSchema).optional();
+    contextDataSchema = z.object({
+      data: z.record(z.string(), z.unknown()),
+      ui: contextUiSchema
+    }).optional();
+    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")
+    });
+    taskContextSchema = taskContextObjectSchema.superRefine(
+      refineContextPublicUrls
+    );
+    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' }
+    );
+    threadUpdateMessageSchema = z.string().min(1).max(500);
+    threadUpdateStatuses = [
+      "info",
+      "queued",
+      "running",
+      "waiting",
+      "succeeded",
+      "failed",
+      "cancelled"
+    ];
+    threadUpdateStatusSchema = z.enum(threadUpdateStatuses);
+    threadUpdateInputSchema = z.object({
+      message: threadUpdateMessageSchema,
+      status: threadUpdateStatusSchema.optional()
+    });
+    taskPriorities = ["low", "normal", "high", "urgent"];
+    taskPrioritySchema = z.enum(taskPriorities);
+    nonNegativeInt = z.number().int().nonnegative();
+    agentCostTokensSchema = z.object({
+      input: nonNegativeInt.optional(),
+      output: nonNegativeInt.optional(),
+      total: nonNegativeInt.optional()
+    });
+    agentCostSchema = z.object({
+      tokens: agentCostTokensSchema.optional(),
+      eur: z.number().nonnegative().optional(),
+      usd: z.number().nonnegative().optional()
+    });
+    AGENT_INFO_MAX_KEYS = 32;
+    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` }
+    );
+    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);
+    threadUpdateBodySchema = threadUpdateInputSchema;
+  }
+});
+
+// src/approval-result.ts
+function toDiscriminatedApprovalResult(actions, task2) {
+  void actions;
+  if (!task2.handled) {
+    throw new Error("Task has no handled result");
+  }
+  return {
+    actionId: task2.handled.action.id,
+    data: task2.handled.action.data,
+    handledBy: task2.handled.handledBy,
+    handledAt: new Date(task2.handledAt ?? Date.now()),
+    taskId: task2.id
+  };
+}
+var TaskTimeoutError, TaskExpiredError;
+var init_approval_result = __esm({
+  "src/approval-result.ts"() {
+    "use strict";
+    TaskTimeoutError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "TaskTimeoutError";
+      }
+    };
+    TaskExpiredError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "TaskExpiredError";
+      }
+    };
+  }
+});
+
+// src/client.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseValidUntilMs(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value instanceof Date) {
+    const ms = value.getTime();
+    return Number.isNaN(ms) ? void 0 : ms;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : void 0;
+  }
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function serializeValidUntil(value) {
+  if (value instanceof Date) {
+    const ms = value.getTime();
+    if (Number.isNaN(ms)) {
+      throw new RobotRockError("Invalid validUntil: Date is invalid", 400);
+    }
+    return value.toISOString();
+  }
+  if (typeof value === "string" && !Number.isNaN(Date.parse(value))) {
+    return new Date(value).toISOString();
+  }
+  throw new RobotRockError("Invalid validUntil: expected a Date or parseable date string", 400);
+}
+function createClient(config) {
+  return new RobotRock(config);
+}
+function attachWebhookToActions(actions, webhook) {
+  return actions.map((action) => ({
+    ...action,
+    handlers: webhookToHandlers(webhook)
+  }));
+}
+function webhookToHandlers(webhook) {
+  return [
+    {
+      type: "webhook",
+      url: webhook.url,
+      headers: webhook.headers ?? {}
+    }
+  ];
+}
+function normalizeSendToHumanInput(task2, clientDefaults) {
+  const {
+    actions,
+    idempotencyKey: _idempotencyKey,
+    assignTo: _assignTo,
+    threadId: _threadId,
+    priority: _priority,
+    update: _update,
+    validUntil,
+    app: taskApp,
+    ...rest
+  } = task2;
+  const webhook = clientDefaults.webhook;
+  const normalizedActions = webhook ? attachWebhookToActions(actions, webhook) : actions;
+  const app = taskApp ?? clientDefaults.app;
+  return {
+    ...rest,
+    version: clientDefaults.version,
+    ...app ? { app } : {},
+    ...validUntil !== void 0 ? { validUntil: serializeValidUntil(validUntil) } : {},
+    actions: normalizedActions
+  };
+}
+async function parseResponseBody(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  const bodyText = await response.text();
+  if (!bodyText) {
+    return null;
+  }
+  if (contentType.toLowerCase().includes("application/json")) {
+    try {
+      return JSON.parse(bodyText);
+    } catch {
+    }
+  }
+  try {
+    return JSON.parse(bodyText);
+  } catch {
+    return bodyText;
+  }
+}
+function getErrorMessage(data, fallback) {
+  if (data && typeof data === "object" && !Array.isArray(data)) {
+    const maybeMessage = data.message;
+    if (typeof maybeMessage === "string" && maybeMessage.trim()) {
+      return maybeMessage;
+    }
+  }
+  if (typeof data === "string" && data.trim()) {
+    const compact = data.replace(/\s+/g, " ").trim();
+    const snippet = compact.length > 180 ? `${compact.slice(0, 180)}...` : compact;
+    return `${fallback}. Server returned non-JSON response: ${snippet}`;
+  }
+  return fallback;
+}
+var DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS, RobotRockError, RobotRock;
+var init_client = __esm({
+  "src/client.ts"() {
+    "use strict";
+    init_schemas();
+    init_approval_result();
+    DEFAULT_POLL_INTERVAL_MS = 2e3;
+    DEFAULT_TIMEOUT_MS = 24 * 60 * 60 * 1e3;
+    RobotRockError = class extends Error {
+      constructor(message, statusCode, response) {
+        super(message);
+        this.statusCode = statusCode;
+        this.response = response;
+        this.name = "RobotRockError";
+      }
+    };
+    RobotRock = class {
+      apiKey;
+      baseUrl;
+      app;
+      version;
+      webhook;
+      polling;
+      constructor(config) {
+        if (config.webhook && config.polling) {
+          throw new Error(
+            "RobotRock client cannot configure both webhook and polling. Use webhook for callbacks or polling to block until handled."
+          );
+        }
+        const apiKey = config.apiKey ?? process.env.ROBOTROCK_API_KEY;
+        if (!apiKey) {
+          throw new Error(
+            "RobotRock API key is required. Set ROBOTROCK_API_KEY or pass apiKey when creating the client."
+          );
+        }
+        this.apiKey = apiKey;
+        const rawBase = config.baseUrl ?? "https://api.robotrock.io/v1";
+        this.baseUrl = rawBase.replace(/\/+$/, "");
+        this.app = config.app;
+        this.version = config.version ?? 2;
+        this.webhook = config.webhook;
+        this.polling = config.polling ?? {};
+      }
+      /**
+       * Create a task via POST /v1 without waiting for a human response.
+       */
+      async createTask(task2) {
+        const normalizedTask = normalizeSendToHumanInput(task2, {
+          webhook: this.webhook,
+          app: this.app,
+          version: this.version
+        });
+        const bodyPayload = {
+          ...normalizedTask,
+          ...task2.assignTo !== void 0 ? { assignTo: task2.assignTo } : {},
+          ...task2.threadId !== void 0 ? { threadId: task2.threadId } : {},
+          ...task2.priority !== void 0 ? { priority: task2.priority } : {},
+          ...task2.update !== void 0 ? { update: task2.update } : {},
+          ...task2.agent !== void 0 ? { agent: task2.agent } : {}
+        };
+        const validation = createTaskBodySchema.safeParse(bodyPayload);
+        if (!validation.success) {
+          throw new RobotRockError(
+            `Invalid task: ${validation.error.issues[0]?.message}`,
+            400,
+            validation.error.issues
+          );
+        }
+        const headers = {
+          "Content-Type": "application/json",
+          "X-Api-Key": this.apiKey
+        };
+        if (task2.idempotencyKey) {
+          headers["Idempotency-Key"] = task2.idempotencyKey;
+        }
+        const response = await fetch(`${this.baseUrl}/`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(validation.data)
+        });
+        const data = await parseResponseBody(response);
+        if (!response.ok) {
+          throw new RobotRockError(
+            getErrorMessage(data, "Failed to create task"),
+            response.status,
+            data
+          );
+        }
+        return data.task;
+      }
+      async sendToHuman(task2) {
+        const normalizedTask = normalizeSendToHumanInput(task2, {
+          webhook: this.webhook,
+          app: this.app,
+          version: this.version
+        });
+        const createdTaskTask = await this.createTask(task2);
+        const hasHandlers = normalizedTask.actions.some(
+          (action) => Array.isArray(action.handlers) && action.handlers.length > 0
+        );
+        if (hasHandlers) {
+          return {
+            mode: "created",
+            task: createdTaskTask
+          };
+        }
+        const timeoutMs = this.polling.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const pollIntervalMs = this.polling.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+        const pollingDeadline = Date.now() + timeoutMs;
+        const validUntilMs = parseValidUntilMs(createdTaskTask.validUntil);
+        const deadline = validUntilMs !== void 0 ? Math.min(pollingDeadline, validUntilMs) : pollingDeadline;
+        const taskId = createdTaskTask.taskId;
+        while (Date.now() < deadline) {
+          const existing = await this.getTask(taskId);
+          if (existing?.status === "handled" && existing.handled) {
+            return {
+              mode: "handled",
+              task: createdTaskTask,
+              ...toDiscriminatedApprovalResult(
+                normalizedTask.actions,
+                existing
+              )
+            };
+          }
+          if (existing?.status === "expired" || existing && Date.now() >= existing.validUntil) {
+            throw new TaskExpiredError("Task reached validUntil before a human completed it");
+          }
+          const remainingMs = deadline - Date.now();
+          await sleep(Math.min(pollIntervalMs, Math.max(0, remainingMs)));
+        }
+        if (validUntilMs !== void 0 && Date.now() >= validUntilMs) {
+          throw new TaskExpiredError("Task reached validUntil before a human completed it");
+        }
+        throw new TaskTimeoutError(`No human response within ${timeoutMs}ms`);
+      }
+      /**
+       * Get a task by public task id (returned as `task.taskId` from {@link sendToHuman}).
+       */
+      async getTask(taskId) {
+        const response = await fetch(`${this.baseUrl}/tasks/${taskId}`, {
+          method: "GET",
+          headers: {
+            "X-Api-Key": this.apiKey
+          }
+        });
+        if (response.status === 404) {
+          return null;
+        }
+        const data = await parseResponseBody(response);
+        if (!response.ok) {
+          throw new RobotRockError(
+            getErrorMessage(data, "Failed to get task"),
+            response.status,
+            data
+          );
+        }
+        return data;
+      }
+      /**
+       * Log a status update against a thread. The update shows in the inbox status
+       * bar and thread update log for every task in the thread.
+       */
+      async sendUpdate({ threadId, message, status }) {
+        if (!threadId) {
+          throw new RobotRockError("threadId is required to send an update", 400);
+        }
+        const validation = threadUpdateBodySchema.safeParse({ message, status });
+        if (!validation.success) {
+          throw new RobotRockError(
+            `Invalid update: ${validation.error.issues[0]?.message}`,
+            400,
+            validation.error.issues
+          );
+        }
+        const response = await fetch(
+          `${this.baseUrl}/threads/${encodeURIComponent(threadId)}/updates`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "X-Api-Key": this.apiKey
+            },
+            body: JSON.stringify(validation.data)
+          }
+        );
+        const data = await parseResponseBody(response);
+        if (!response.ok) {
+          throw new RobotRockError(
+            getErrorMessage(data, "Failed to send update"),
+            response.status,
+            data
+          );
+        }
+        return data.update;
+      }
+      async cancelTask(taskId) {
+        const response = await fetch(`${this.baseUrl}/tasks/${taskId}/cancel`, {
+          method: "POST",
+          headers: {
+            "X-Api-Key": this.apiKey
+          }
+        });
+        if (!response.ok) {
+          const data = await parseResponseBody(response);
+          throw new RobotRockError(
+            getErrorMessage(data, "Failed to cancel task"),
+            response.status,
+            data
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/env.ts
+function resolveRobotRockConfig(overrides) {
+  const apiKey = overrides?.apiKey ?? process.env.ROBOTROCK_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "RobotRock API key is required. Set ROBOTROCK_API_KEY or pass apiKey when creating the client."
+    );
+  }
+  const baseUrl = overrides?.baseUrl ?? process.env.ROBOTROCK_BASE_URL ?? process.env.ROBOTROCK_API_URL ?? DEFAULT_BASE_URL;
+  const app = overrides?.app ?? process.env.ROBOTROCK_APP;
+  return app ? { apiKey, baseUrl, app } : { apiKey, baseUrl };
+}
+var DEFAULT_BASE_URL;
+var init_env = __esm({
+  "src/env.ts"() {
+    "use strict";
+    init_client();
+    DEFAULT_BASE_URL = "https://api.robotrock.io/v1";
+  }
+});
+
+// src/handler-webhook.ts
+function isRobotRockHandlerWebhookPayload(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const v = value;
+  if (typeof v.taskId !== "string" || typeof v.handledAt !== "string") {
+    return false;
+  }
+  const action = v.action;
+  if (typeof action !== "object" || action === null) {
+    return false;
+  }
+  const a = action;
+  return typeof a.id === "string" && "data" in a;
+}
+var init_handler_webhook = __esm({
+  "src/handler-webhook.ts"() {
+    "use strict";
+  }
+});
+
+// src/wait-timing.ts
+function resolveWaitTiming(validUntilInput) {
+  const validUntilMs = validUntilInput !== void 0 ? parseValidUntilMs2(validUntilInput) : Date.now() + DEFAULT_WAIT_DURATION_MS;
+  const durationMs = validUntilMs - Date.now();
+  if (durationMs <= 0) {
+    throw new Error("validUntil must be in the future");
+  }
+  return {
+    validUntil: validUntilInput ?? new Date(validUntilMs),
+    timeout: durationMsToTimeout(durationMs)
+  };
+}
+function parseValidUntilMs2(value) {
+  if (value instanceof Date) {
+    const ms = value.getTime();
+    if (Number.isNaN(ms)) {
+      throw new Error("Invalid validUntil: Date is invalid");
+    }
+    return ms;
+  }
+  const parsed = Date.parse(value);
+  if (Number.isNaN(parsed)) {
+    throw new Error("Invalid validUntil: expected a parseable date string");
+  }
+  return parsed;
+}
+function durationMsToTimeout(durationMs) {
+  const seconds = Math.ceil(durationMs / 1e3);
+  if (seconds <= 0) {
+    throw new Error("validUntil must be in the future");
+  }
+  if (seconds >= 86400) {
+    return `${Math.ceil(seconds / 86400)}d`;
+  }
+  if (seconds >= 3600) {
+    return `${Math.ceil(seconds / 3600)}h`;
+  }
+  if (seconds >= 60) {
+    return `${Math.ceil(seconds / 60)}m`;
+  }
+  return `${seconds}s`;
+}
+var DEFAULT_WAIT_DURATION_MS;
+var init_wait_timing = __esm({
+  "src/wait-timing.ts"() {
+    "use strict";
+    DEFAULT_WAIT_DURATION_MS = 7 * 24 * 60 * 60 * 1e3;
+  }
+});
+
+// src/trigger/index.ts
+var trigger_exports = {};
+__export(trigger_exports, {
+  approveByHumanTask: () => approveByHumanTask,
+  sendToHumanTask: () => sendToHumanTask
+});
+import { task, wait } from "@trigger.dev/sdk";
+async function runSendToHuman(payload) {
+  const { validUntil: validUntilInput, ...taskInput } = payload;
+  const { validUntil, timeout } = resolveWaitTiming(validUntilInput);
+  const token = await wait.createToken({ timeout });
+  const baseConfig = resolveRobotRockConfig();
+  const client = createClient({
+    apiKey: baseConfig.apiKey,
+    baseUrl: baseConfig.baseUrl,
+    ...baseConfig.app ? { app: baseConfig.app } : {},
+    ...baseConfig.version ? { version: baseConfig.version } : {},
+    webhook: { url: token.url }
+  });
+  const sendResult = await client.sendToHuman({
+    ...taskInput,
+    validUntil
+  });
+  const outcome = await wait.forToken(token.id);
+  if (!outcome.ok) {
+    throw new Error(`Human response timed out before validUntil (${timeout})`);
+  }
+  const output = outcome.output;
+  if (!isRobotRockHandlerWebhookPayload(output)) {
+    throw new Error(
+      "Wait token completed with unexpected payload; expected RobotRock handler body (taskId, action.id, action.data)."
+    );
+  }
+  return toDiscriminatedApprovalResult(
+    payload.actions,
+    {
+      id: output.taskId,
+      createdAt: /* @__PURE__ */ new Date(),
+      status: "handled",
+      context: sendResult.task.context,
+      validUntil: Date.now(),
+      handledAt: new Date(output.handledAt).getTime(),
+      handled: {
+        action: {
+          id: output.action.id,
+          data: output.action.data
+        },
+        handledBy: output.handledBy
+      }
+    }
+  );
+}
+var APPROVE_BY_HUMAN_ACTIONS, sendToHumanTask, approveByHumanTask;
+var init_trigger = __esm({
+  "src/trigger/index.ts"() {
+    "use strict";
+    init_client();
+    init_env();
+    init_approval_result();
+    init_handler_webhook();
+    init_wait_timing();
+    APPROVE_BY_HUMAN_ACTIONS = [
+      { id: "approve", title: "Approve" },
+      { id: "decline", title: "Decline" }
+    ];
+    sendToHumanTask = task({
+      id: "robotrock/send-to-human",
+      run: async (payload) => runSendToHuman(payload)
+    });
+    approveByHumanTask = task({
+      id: "robotrock/approve-by-human",
+      run: async (payload) => runSendToHuman({
+        ...payload,
+        actions: APPROVE_BY_HUMAN_ACTIONS
+      })
+    });
+  }
+});
+
+// src/workflow/index.ts
+var workflow_exports = {};
+__export(workflow_exports, {
+  approveByHumanInWorkflow: () => approveByHumanInWorkflow,
+  sendToHumanInWorkflow: () => sendToHumanInWorkflow,
+  sendUpdateInWorkflow: () => sendUpdateInWorkflow
+});
+import { createWebhook, sleep as sleep2 } from "workflow";
+async function createRobotRockTaskForWebhook(input) {
+  "use step";
+  const baseConfig = resolveRobotRockConfig();
+  const client = createClient({
+    apiKey: baseConfig.apiKey,
+    baseUrl: baseConfig.baseUrl,
+    ...input.app ?? baseConfig.app ? { app: input.app ?? baseConfig.app } : {},
+    ...baseConfig.version ? { version: baseConfig.version } : {},
+    webhook: { url: input.webhookUrl }
+  });
+  return client.sendToHuman({
+    ...input.taskInput,
+    validUntil: input.validUntil
+  });
+}
+async function parseRobotRockWebhookRequest(request) {
+  "use step";
+  const body = await request.json();
+  if (!isRobotRockHandlerWebhookPayload(body)) {
+    throw new Error(
+      "Workflow webhook completed with unexpected payload; expected RobotRock handler body (taskId, action.id, action.data)."
+    );
+  }
+  return body;
+}
+async function sendToHumanInWorkflow(payload) {
+  var _stack = [];
+  try {
+    const { validUntil: validUntilInput, app, ...taskInput } = payload;
+    const { validUntil, timeout } = resolveWaitTiming(validUntilInput);
+    const timeoutMs = parseValidUntilMs2(validUntil) - Date.now();
+    const webhook = __using(_stack, createWebhook());
+    const sendResult = await createRobotRockTaskForWebhook({
+      webhookUrl: webhook.url,
+      app,
+      validUntil,
+      taskInput
+    });
+    const outcome = await Promise.race([
+      webhook.then((request) => parseRobotRockWebhookRequest(request)),
+      sleep2(timeoutMs).then(() => ({ timedOut: true }))
+    ]);
+    if ("timedOut" in outcome) {
+      throw new Error(`Human response timed out before validUntil (${timeout})`);
+    }
+    const output = outcome;
+    return toDiscriminatedApprovalResult(payload.actions, {
+      id: output.taskId,
+      createdAt: /* @__PURE__ */ new Date(),
+      status: "handled",
+      context: sendResult.task.context,
+      validUntil: Date.now(),
+      handledAt: new Date(output.handledAt).getTime(),
+      handled: {
+        action: {
+          id: output.action.id,
+          data: output.action.data
+        },
+        handledBy: output.handledBy
+      }
+    });
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+async function approveByHumanInWorkflow(payload) {
+  return sendToHumanInWorkflow({
+    ...payload,
+    actions: APPROVE_BY_HUMAN_ACTIONS2
+  });
+}
+async function sendRobotRockUpdate(payload) {
+  "use step";
+  const { app, ...update } = payload;
+  const baseConfig = resolveRobotRockConfig();
+  const client = createClient({
+    apiKey: baseConfig.apiKey,
+    baseUrl: baseConfig.baseUrl,
+    ...app ?? baseConfig.app ? { app: app ?? baseConfig.app } : {},
+    ...baseConfig.version ? { version: baseConfig.version } : {}
+  });
+  return client.sendUpdate(update);
+}
+async function sendUpdateInWorkflow(payload) {
+  return sendRobotRockUpdate(payload);
+}
+var APPROVE_BY_HUMAN_ACTIONS2;
+var init_workflow = __esm({
+  "src/workflow/index.ts"() {
+    "use strict";
+    init_client();
+    init_env();
+    init_approval_result();
+    init_handler_webhook();
+    init_wait_timing();
+    APPROVE_BY_HUMAN_ACTIONS2 = [
+      { id: "approve", title: "Approve" },
+      { id: "decline", title: "Decline" }
+    ];
+  }
+});
+
+// src/ai/approve-by-human-tool.ts
+import { tool } from "ai";
+
+// src/ai/approve-by-human-tool-core.ts
+import { z as z2 } from "zod";
+
+// src/ai/context.ts
+init_client();
+init_env();
+var APPROVE_BY_HUMAN_ACTIONS3 = [
+  { id: "approve", title: "Approve" },
+  { id: "decline", title: "Decline" }
+];
+function createRobotRockAiTriggerContext(options = {}) {
+  return { mode: "trigger", ...options };
+}
+function isRobotRockClient(value) {
+  return typeof value === "object" && value !== null && "sendToHuman" in value && typeof value.sendToHuman === "function";
+}
+function normalizeRobotRockAiContext(clientOrContext) {
+  if (isRobotRockClient(clientOrContext)) {
+    return { mode: "polling", client: clientOrContext };
+  }
+  if (clientOrContext.mode === "trigger" || clientOrContext.mode === "workflow") {
+    return clientOrContext;
+  }
+  if (clientOrContext.mode === "polling" || clientOrContext.mode === void 0) {
+    if (!("client" in clientOrContext) || !clientOrContext.client) {
+      throw new Error("RobotRock AI polling mode requires `client` on the context object.");
+    }
+    return { mode: "polling", client: clientOrContext.client };
+  }
+  throw new Error(`Unknown RobotRock AI mode: ${String(clientOrContext.mode)}`);
+}
+async function sendToHumanForAi(context, payload) {
+  if (context.mode === "trigger") {
+    const { sendToHumanTask: sendToHumanTask2 } = await Promise.resolve().then(() => (init_trigger(), trigger_exports));
+    const waitResult = await sendToHumanTask2.triggerAndWait({
+      ...payload,
+      ...context.app ? { app: context.app } : {}
+    });
+    if (!waitResult.ok) {
+      throw waitResult.error;
+    }
+    return waitResult.output;
+  }
+  if (context.mode === "workflow") {
+    const { sendToHumanInWorkflow: sendToHumanInWorkflow2 } = await Promise.resolve().then(() => (init_workflow(), workflow_exports));
+    const result2 = await sendToHumanInWorkflow2({
+      ...payload,
+      ...context.app ? { app: context.app } : {}
+    });
+    return result2;
+  }
+  const result = await context.client.sendToHuman(payload);
+  if (result.mode !== "handled") {
+    throw new Error(
+      "RobotRock task was created but not handled. Configure client polling or webhook, or use mode: 'trigger' / 'workflow' for durable waits."
+    );
+  }
+  return {
+    actionId: result.actionId,
+    data: result.data,
+    handledBy: result.handledBy,
+    handledAt: result.handledAt,
+    taskId: result.taskId
+  };
+}
+async function sendUpdateForAi(context, payload) {
+  if (context.mode === "workflow") {
+    const { sendUpdateInWorkflow: sendUpdateInWorkflow2 } = await Promise.resolve().then(() => (init_workflow(), workflow_exports));
+    return sendUpdateInWorkflow2({
+      ...payload,
+      ...context.app ? { app: context.app } : {}
+    });
+  }
+  if (context.mode === "trigger") {
+    const client = createClient(
+      resolveRobotRockConfig(context.app ? { app: context.app } : void 0)
+    );
+    return client.sendUpdate(payload);
+  }
+  return context.client.sendUpdate(payload);
+}
+async function approveByHumanForAi(context, payload) {
+  if (context.mode === "trigger") {
+    const { approveByHumanTask: approveByHumanTask2 } = await Promise.resolve().then(() => (init_trigger(), trigger_exports));
+    const waitResult = await approveByHumanTask2.triggerAndWait({
+      ...payload,
+      ...context.app ? { app: context.app } : {}
+    });
+    if (!waitResult.ok) {
+      throw waitResult.error;
+    }
+    return waitResult.output;
+  }
+  if (context.mode === "workflow") {
+    const { approveByHumanInWorkflow: approveByHumanInWorkflow2 } = await Promise.resolve().then(() => (init_workflow(), workflow_exports));
+    return await approveByHumanInWorkflow2({
+      ...payload,
+      ...context.app ? { app: context.app } : {}
+    });
+  }
+  const result = await context.client.sendToHuman({
+    ...payload,
+    actions: APPROVE_BY_HUMAN_ACTIONS3
+  });
+  if (result.mode !== "handled") {
+    throw new Error(
+      "RobotRock approval was not handled. Configure client polling or use mode: 'trigger' / 'workflow' for durable waits."
+    );
+  }
+  return {
+    actionId: result.actionId,
+    data: result.data,
+    handledBy: result.handledBy,
+    handledAt: result.handledAt,
+    taskId: result.taskId
+  };
+}
+
+// src/ai/human-tool-result.ts
+var APPROVE_IDS = /* @__PURE__ */ new Set(["approve", "approved"]);
+var DECLINE_IDS = /* @__PURE__ */ new Set(["decline", "reject", "deny", "denied"]);
+function toHumanToolResult(result) {
+  const payload = {
+    taskId: result.taskId,
+    actionId: result.actionId,
+    data: result.data,
+    handledBy: result.handledBy,
+    handledAt: result.handledAt.toISOString()
+  };
+  if (APPROVE_IDS.has(result.actionId)) {
+    payload.approved = true;
+  } else if (DECLINE_IDS.has(result.actionId)) {
+    payload.approved = false;
+  }
+  return payload;
+}
+
+// src/ai/approve-by-human-tool-core.ts
+var approveByHumanInputSchema = z2.object({
+  type: z2.string().optional().describe("Task type slug; defaults to ai-approval"),
+  name: z2.string().describe("Short title for the approval request"),
+  description: z2.string().describe("What needs approval and the consequences of approving or declining"),
+  contextSummary: z2.string().optional().describe("Optional markdown summary shown to the reviewer")
+});
+function resolveApproveByHumanToolConfig(clientOrContext, maybeOptions = {}) {
+  const isDurable = typeof clientOrContext === "object" && clientOrContext !== null && "mode" in clientOrContext && (clientOrContext.mode === "trigger" || clientOrContext.mode === "workflow");
+  const aiContext = normalizeRobotRockAiContext(
+    isDurable ? {
+      mode: clientOrContext.mode,
+      app: clientOrContext.app
+    } : clientOrContext
+  );
+  const options = isDurable ? clientOrContext : maybeOptions;
+  return { aiContext, options };
+}
+function buildApproveByHumanToolDefinition(clientOrContext, maybeOptions = {}) {
+  const { aiContext, options } = resolveApproveByHumanToolConfig(
+    clientOrContext,
+    maybeOptions
+  );
+  const description = options.description ?? "Request explicit human approval before a sensitive or irreversible step. Returns whether the human approved or declined.";
+  return {
+    description,
+    inputSchema: approveByHumanInputSchema,
+    execute: async (input) => {
+      const taskContext = input.contextSummary !== void 0 ? {
+        data: { summary: input.contextSummary },
+        ui: {
+          summary: { "ui:widget": "textarea", "ui:options": { rows: 6 } }
+        }
+      } : void 0;
+      const result = await approveByHumanForAi(aiContext, {
+        type: input.type ?? options.defaultType ?? "ai-approval",
+        name: input.name,
+        description: input.description,
+        context: taskContext
+      });
+      return toHumanToolResult(result);
+    }
+  };
+}
+
+// src/ai/approve-by-human-tool.ts
+function approveByHumanTool(clientOrContext, maybeOptions = {}) {
+  return tool(buildApproveByHumanToolDefinition(clientOrContext, maybeOptions));
+}
+
+// src/ai/create-send-to-human-tool.ts
+import { tool as tool2 } from "ai";
+
+// src/ai/create-send-to-human-tool-core.ts
+init_schemas();
+import { z as z3 } from "zod";
+var sendToHumanToolInputSchema = z3.object({
+  type: z3.string().describe("Task type slug shown in the RobotRock inbox"),
+  name: z3.string().describe("Short title for the human reviewer"),
+  description: z3.string().optional().describe("What you need from the human and why you cannot proceed alone"),
+  context: z3.object({
+    data: z3.record(z3.string(), z3.unknown()).optional(),
+    ui: z3.record(z3.string(), z3.unknown()).optional()
+  }).optional().describe("Optional structured context for the inbox UI"),
+  validUntil: z3.string().datetime().optional().describe("Optional ISO deadline for the task"),
+  assignTo: assignToSchema.optional().describe(
+    "Assign to tenant member emails and/or group slugs; narrows who sees the task in the inbox"
+  )
+});
+function resolveSendToHumanToolConfig(clientOrOptions, maybeOptions) {
+  const isDurable = typeof clientOrOptions === "object" && clientOrOptions !== null && "mode" in clientOrOptions && (clientOrOptions.mode === "trigger" || clientOrOptions.mode === "workflow");
+  const aiContext = normalizeRobotRockAiContext(
+    isDurable ? {
+      mode: clientOrOptions.mode,
+      app: clientOrOptions.app
+    } : clientOrOptions
+  );
+  const options = isDurable ? clientOrOptions : maybeOptions;
+  return { aiContext, options };
+}
+function buildSendToHumanToolDefinition(clientOrOptions, maybeOptions) {
+  const { aiContext, options } = resolveSendToHumanToolConfig(clientOrOptions, maybeOptions);
+  const description = options.description ?? "Request structured input or a decision from a human in the RobotRock inbox. Use when you lack required information, need policy approval, or must confirm an irreversible step.";
+  return {
+    description,
+    inputSchema: sendToHumanToolInputSchema,
+    execute: async (input) => {
+      const taskContext = input.context ? {
+        data: input.context.data ?? {},
+        ui: input.context.ui
+      } : void 0;
+      const payload = {
+        type: input.type ?? options.defaultType ?? "ai-human-input",
+        name: input.name,
+        description: input.description,
+        context: taskContext,
+        validUntil: input.validUntil,
+        assignTo: input.assignTo,
+        actions: options.actions,
+        ...options.threadId ? { threadId: options.threadId } : {}
+      };
+      const result = await sendToHumanForAi(aiContext, payload);
+      return toHumanToolResult(result);
+    }
+  };
+}
+
+// src/ai/create-send-to-human-tool.ts
+function createSendToHumanTool(clientOrOptions, maybeOptions) {
+  return tool2(buildSendToHumanToolDefinition(clientOrOptions, maybeOptions));
+}
+
+// src/ai/create-send-update-tool.ts
+import { tool as tool3 } from "ai";
+
+// src/ai/create-send-update-tool-core.ts
+init_schemas();
+init_client();
+import { z as z4 } from "zod";
+var sendUpdateToolInputSchema = z4.object({
+  threadId: z4.string().optional().describe(
+    "Thread to post the update to. Use the `threadId` returned by a prior send-to-human task. Omit only when a session threadId is configured on the tool."
+  ),
+  message: z4.string().describe("Short progress update (1-2 sentences) shown in the inbox status bar"),
+  status: threadUpdateStatusSchema.optional().describe(
+    "Lifecycle status driving the status-bar icon/color: info, queued, running, waiting, succeeded, failed, cancelled"
+  )
+});
+function resolveSendUpdateToolConfig(clientOrOptions, maybeOptions = {}) {
+  const isDurable = typeof clientOrOptions === "object" && clientOrOptions !== null && "mode" in clientOrOptions && (clientOrOptions.mode === "trigger" || clientOrOptions.mode === "workflow");
+  const aiContext = normalizeRobotRockAiContext(
+    isDurable ? {
+      mode: clientOrOptions.mode,
+      app: clientOrOptions.app
+    } : clientOrOptions
+  );
+  const options = isDurable ? clientOrOptions : maybeOptions;
+  return { aiContext, options };
+}
+function buildSendUpdateToolDefinition(clientOrOptions, maybeOptions = {}) {
+  const { aiContext, options } = resolveSendUpdateToolConfig(clientOrOptions, maybeOptions);
+  const description = options.description ?? "Post a short progress update to the RobotRock thread you are working on. Use to report status changes (running, succeeded, failed) so humans can follow along in the inbox.";
+  return {
+    description,
+    inputSchema: sendUpdateToolInputSchema,
+    execute: async (input) => {
+      const threadId = input.threadId ?? options.threadId;
+      if (!threadId) {
+        throw new Error(
+          "createSendUpdateTool: no threadId. Pass `threadId` from a prior send-to-human result, or configure a session `threadId` in the tool options."
+        );
+      }
+      try {
+        const update = await sendUpdateForAi(aiContext, {
+          threadId,
+          message: input.message,
+          status: input.status
+        });
+        return { posted: true, threadId, update };
+      } catch (error) {
+        if (error instanceof RobotRockError && error.statusCode === 404) {
+          return {
+            posted: false,
+            threadId,
+            reason: "thread_not_found",
+            message: `No task exists for thread "${threadId}" yet, so the update was not posted. Create a task on this thread with send-to-human before reporting progress.`
+          };
+        }
+        throw error;
+      }
+    }
+  };
+}
+
+// src/ai/create-send-update-tool.ts
+function createSendUpdateTool(clientOrOptions, maybeOptions = {}) {
+  return tool3(buildSendUpdateToolDefinition(clientOrOptions, maybeOptions));
+}
+
+// src/ai/format-tool-approval-task.ts
+function defaultFormatToolApprovalTask(toolCall, options = {}) {
+  const approveId = options.approveActionId ?? "approve";
+  const denyId = options.denyActionId ?? "deny";
+  let inputPreview;
+  try {
+    inputPreview = JSON.stringify(toolCall.input, null, 2);
+  } catch {
+    inputPreview = String(toolCall.input);
+  }
+  return {
+    type: options.type ?? "ai-tool-approval",
+    name: `Approve: ${toolCall.toolName}`,
+    description: `Review the proposed \`${toolCall.toolName}\` tool call before it runs.`,
+    context: {
+      data: {
+        toolName: toolCall.toolName,
+        toolCallId: toolCall.toolCallId,
+        input: toolCall.input
+      },
+      ui: {
+        toolName: { "ui:widget": "text" },
+        toolCallId: { "ui:widget": "text" },
+        input: { "ui:widget": "textarea" }
+      }
+    },
+    actions: [
+      { id: approveId, title: "Approve execution" },
+      { id: denyId, title: "Deny" }
+    ]
+  };
+}
+
+// src/ai/tool-approval-bridge.ts
+function buildToolMatcher(config) {
+  const names = config.tools ? new Set(config.tools) : null;
+  return (toolCall) => {
+    if (config.when?.(toolCall)) {
+      return true;
+    }
+    if (names && names.has(toolCall.toolName)) {
+      return true;
+    }
+    return false;
+  };
+}
+function createRobotRockToolApproval(config) {
+  const matches = buildToolMatcher(config);
+  const toolApproval = async (options) => {
+    return matches(options.toolCall) ? "user-approval" : void 0;
+  };
+  return toolApproval;
+}
+function createRobotRockNeedsApproval(config) {
+  const matches = buildToolMatcher(config);
+  return async (_input, options) => {
+    const toolCall = findToolCallInMessages(options.messages, options.toolCallId);
+    if (!toolCall) {
+      return false;
+    }
+    return matches(toolCall);
+  };
+}
+function applyRobotRockToolApprovalToTools(tools, config) {
+  const names = config.tools ? new Set(config.tools) : null;
+  const needsApproval = createRobotRockNeedsApproval(config);
+  const next = { ...tools };
+  for (const key of Object.keys(tools)) {
+    const name = String(key);
+    const shouldApply = names && names.has(name) || names === null && config.when !== void 0;
+    if (!shouldApply) {
+      continue;
+    }
+    const existing = tools[key];
+    next[key] = {
+      ...existing,
+      needsApproval
+    };
+  }
+  return next;
+}
+function findToolCallInMessages(messages, toolCallId) {
+  if (!messages) {
+    return void 0;
+  }
+  for (const message of messages) {
+    if (typeof message !== "object" || message === null) {
+      continue;
+    }
+    const role = message.role;
+    if (role !== "assistant") {
+      continue;
+    }
+    const content = message.content;
+    if (!Array.isArray(content)) {
+      continue;
+    }
+    for (const part of content) {
+      if (typeof part !== "object" || part === null) {
+        continue;
+      }
+      const p = part;
+      if (p.type === "tool-call" && p.toolCallId === toolCallId) {
+        return {
+          toolName: String(p.toolName ?? ""),
+          toolCallId,
+          input: p.input
+        };
+      }
+    }
+  }
+  return void 0;
+}
+function collectApprovalRequests(source) {
+  const requests = [];
+  const visit = (value) => {
+    if (!value) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        visit(item);
+      }
+      return;
+    }
+    if (typeof value !== "object") {
+      return;
+    }
+    const obj = value;
+    if (obj.type === "tool-approval-request" && typeof obj.approvalId === "string") {
+      if (obj.isAutomatic === true) {
+        return;
+      }
+      const embedded = obj.toolCall;
+      const toolCallId = typeof obj.toolCallId === "string" ? obj.toolCallId : typeof embedded?.toolCallId === "string" ? embedded.toolCallId : void 0;
+      let toolCall;
+      if (embedded && typeof embedded.toolName === "string") {
+        toolCall = {
+          toolName: embedded.toolName,
+          toolCallId: String(embedded.toolCallId ?? toolCallId ?? ""),
+          input: embedded.input
+        };
+      } else if (toolCallId) {
+        toolCall = findToolCallInMessages(
+          source.messages,
+          toolCallId
+        );
+      }
+      requests.push({
+        type: "tool-approval-request",
+        approvalId: obj.approvalId,
+        toolCallId,
+        toolCall,
+        isAutomatic: obj.isAutomatic === true
+      });
+      return;
+    }
+    if (Array.isArray(obj.content)) {
+      visit(obj.content);
+    }
+    if (Array.isArray(obj.steps)) {
+      visit(obj.steps);
+    }
+    if (obj.response && typeof obj.response === "object") {
+      visit(obj.response.messages);
+    }
+  };
+  visit(source);
+  if (typeof source === "object" && source !== null && Array.isArray(source.content)) {
+    visit(source.content);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return requests.filter((r) => {
+    if (seen.has(r.approvalId)) {
+      return false;
+    }
+    seen.add(r.approvalId);
+    return true;
+  });
+}
+function resolveToolCallForRequest(request, source, messages) {
+  if (request.toolCall) {
+    return request.toolCall;
+  }
+  const toolCallId = request.toolCallId;
+  if (toolCallId) {
+    const fromMessages = findToolCallInMessages(messages, toolCallId);
+    if (fromMessages) {
+      return fromMessages;
+    }
+  }
+  if (typeof source === "object" && source !== null && Array.isArray(source.toolCalls)) {
+    for (const call of source.toolCalls) {
+      if (call.toolCallId === toolCallId) {
+        return {
+          toolName: String(call.toolName ?? ""),
+          toolCallId: String(call.toolCallId ?? ""),
+          input: call.input
+        };
+      }
+    }
+  }
+  throw new Error(
+    `Could not resolve tool call for approval ${request.approvalId}. Pass messages that include the assistant tool-call.`
+  );
+}
+async function resolveToolApprovalsViaRobotRock(clientOrContext, source, options = {}) {
+  const context = normalizeRobotRockAiContext(clientOrContext);
+  const approveId = options.approveActionId ?? "approve";
+  const denyId = options.denyActionId ?? "deny";
+  const formatTask = options.formatTask ?? defaultFormatToolApprovalTask;
+  const baseMessages = typeof source === "object" && source !== null && Array.isArray(source.messages) ? [...source.messages] : [];
+  const requests = collectApprovalRequests(source);
+  const responses = [];
+  for (const request of requests) {
+    const toolCall = resolveToolCallForRequest(request, source, baseMessages);
+    const taskInput = formatTask(toolCall, {
+      approveActionId: approveId,
+      denyActionId: denyId
+    });
+    const result = await sendToHumanForAi(context, taskInput);
+    const approved = result.actionId === approveId;
+    const reason = typeof result.data === "object" && result.data !== null && "reason" in result.data && typeof result.data.reason === "string" ? result.data.reason : approved ? "Approved in RobotRock inbox" : "Denied in RobotRock inbox";
+    responses.push({
+      type: "tool-approval-response",
+      approvalId: request.approvalId,
+      approved,
+      reason
+    });
+  }
+  const messages = [...baseMessages];
+  if (responses.length > 0) {
+    messages.push({ role: "tool", content: responses });
+  }
+  return { responses, messages };
+}
+async function runWithRobotRockApprovals(options) {
+  const clientOrContext = options.context ?? (options.client ? options.client : (() => {
+    throw new Error("runWithRobotRockApprovals requires `client` or `context`.");
+  })());
+  const maxRounds = options.maxRounds ?? 20;
+  let messages = options.messages ? [...options.messages] : [];
+  let lastResult;
+  for (let round = 0; round < maxRounds; round++) {
+    lastResult = await options.generate(messages);
+    const { responses, messages: nextMessages } = await resolveToolApprovalsViaRobotRock(
+      clientOrContext,
+      { ...lastResult, messages },
+      options.resolveOptions
+    );
+    if (responses.length === 0) {
+      return lastResult;
+    }
+    messages = nextMessages;
+  }
+  throw new Error(`RobotRock approval loop exceeded maxRounds (${maxRounds})`);
+}
+
+// src/ai/create-ai-tools.ts
+function createRobotRockAiTools(options) {
+  const mode = options.mode ?? (options.client ? "polling" : "trigger");
+  if (mode === "polling" && !options.client) {
+    throw new Error("createRobotRockAiTools: polling mode requires `client`.");
+  }
+  const context = mode === "trigger" ? { mode: "trigger", app: options.app } : mode === "workflow" ? { mode: "workflow", app: options.app } : { mode: "polling", client: options.client };
+  const durableContext = context.mode === "trigger" || context.mode === "workflow" ? context : null;
+  const pollingClient = context.mode === "polling" ? context.client : void 0;
+  return {
+    context,
+    approveByHuman: (toolOptions) => durableContext ? approveByHumanTool({ ...durableContext, ...toolOptions }) : approveByHumanTool(pollingClient, toolOptions),
+    sendToHuman: (toolOptions) => durableContext ? createSendToHumanTool({
+      ...durableContext,
+      ...options.threadId ? { threadId: options.threadId } : {},
+      ...toolOptions
+    }) : createSendToHumanTool(pollingClient, {
+      ...options.threadId ? { threadId: options.threadId } : {},
+      ...toolOptions
+    }),
+    sendUpdate: (toolOptions = {}) => durableContext ? createSendUpdateTool({
+      ...durableContext,
+      ...options.threadId ? { threadId: options.threadId } : {},
+      ...toolOptions
+    }) : createSendUpdateTool(pollingClient, {
+      ...options.threadId ? { threadId: options.threadId } : {},
+      ...toolOptions
+    })
+  };
+}
 export {
   applyRobotRockToolApprovalToTools,
   approveByHumanTool,