robotrock 0.1.0

package/README.md

@@ -0,0 +1,87 @@
+# robotrock
+
+Human-in-the-loop approval workflows for AI agents.
+
+## Installation
+
+```bash
+npm install robotrock
+# or
+bun add robotrock
+```
+
+For Trigger.dev, also install `@trigger.dev/sdk`.
+
+## Quick Start
+
+```typescript
+import { RobotRock, askHuman } from "robotrock";
+
+// Or create a client explicitly
+const client = new RobotRock({ apiKey: process.env.ROBOTROCK_API_KEY! });
+
+const response = await client.createTask({
+  type: "budget-approval",
+  name: "Q1 Budget Approval",
+  actions: [
+    { id: "approve", title: "Approve" },
+    { id: "reject", title: "Reject" },
+  ],
+});
+```
+
+## Block until a human responds
+
+```typescript
+import { askHuman } from "robotrock";
+
+const result = await askHuman({
+  task: {
+    type: "approval",
+    name: "Review change",
+    actions: [
+      { id: "approve", title: "Approve" },
+      { id: "reject", title: "Reject" },
+    ] as const,
+  },
+});
+```
+
+Uses `ROBOTROCK_API_KEY` from the environment when no `client` is passed.
+
+## Trigger.dev
+
+```typescript
+import { task } from "@trigger.dev/sdk/v3";
+import { askHuman } from "robotrock/trigger";
+
+export const deploymentApproval = task({
+  id: "deployment-approval",
+  run: async () => {
+    const result = await askHuman({
+      task: {
+        type: "deployment",
+        name: "Deploy to production",
+        actions: [
+          { id: "approve", title: "Deploy" },
+          { id: "reject", title: "Cancel" },
+        ],
+      },
+      timeout: "1h",
+    });
+
+    return result.actionId === "approve";
+  },
+});
+```
+
+## Exports
+
+| Import | Description |
+|--------|-------------|
+| `robotrock` | Client, `askHuman` (poll), types, schemas |
+| `robotrock/trigger` | `askHuman` via Trigger waitpoint tokens |
+
+## License
+
+MIT

package/dist/chunk-TUQXDKV6.js

@@ -0,0 +1,209 @@
+// ../core/src/schemas/task.ts
+import { z } from "zod";
+var safeUrlSchema = z.string().refine((url) => url.startsWith("http://") || url.startsWith("https://"), {
+  message: "URL must start with http:// or https://"
+});
+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())
+});
+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.unknown()).optional(),
+  // Optional handlers for this action - if present, must have at least 1
+  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.unknown()).optional(),
+  items: z.lazy(() => z.record(uiFieldSchemaSchema)).optional()
+}).passthrough();
+var contextUiSchema = z.record(uiFieldSchemaSchema).optional();
+var contextDataSchema = z.object({
+  data: z.record(z.unknown()),
+  ui: contextUiSchema
+}).optional();
+var taskContextSchema = z.object({
+  /** Source application id; omitted tasks are grouped in the default inbox. */
+  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")
+});
+
+// src/client.ts
+var RobotRockError = class extends Error {
+  constructor(message, statusCode, response) {
+    super(message);
+    this.statusCode = statusCode;
+    this.response = response;
+    this.name = "RobotRockError";
+  }
+};
+var RobotRock = class {
+  apiKey;
+  baseUrl;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("API key is required");
+    }
+    this.apiKey = config.apiKey;
+    const rawBase = config.baseUrl ?? "https://api.robotrock.com/v1";
+    this.baseUrl = rawBase.replace(/\/+$/, "");
+  }
+  async createTask(task, options) {
+    const validation = taskContextSchema.safeParse(task);
+    if (!validation.success) {
+      throw new RobotRockError(
+        `Invalid task: ${validation.error.errors[0]?.message}`,
+        400,
+        validation.error.errors
+      );
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Api-Key": this.apiKey
+    };
+    if (options?.idempotencyKey) {
+      headers["Idempotency-Key"] = options.idempotencyKey;
+    }
+    const response = await fetch(`${this.baseUrl}/`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(validation.data)
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      throw new RobotRockError(
+        data.message ?? "Failed to create task",
+        response.status,
+        data
+      );
+    }
+    return data;
+  }
+  /**
+   * Get a task by Redis stream entry id (returned as `task.streamId` from {@link createTask}).
+   */
+  async getTask(streamEntryId) {
+    const response = await fetch(`${this.baseUrl}/tasks/${streamEntryId}`, {
+      method: "GET",
+      headers: {
+        "X-Api-Key": this.apiKey
+      }
+    });
+    if (response.status === 404) {
+      return null;
+    }
+    const data = await response.json();
+    if (!response.ok) {
+      throw new RobotRockError(
+        data.message ?? "Failed to get task",
+        response.status,
+        data
+      );
+    }
+    return data;
+  }
+  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 response.json();
+      throw new RobotRockError(
+        data.message ?? "Failed to cancel task",
+        response.status,
+        data
+      );
+    }
+  }
+};
+function createClient(config) {
+  return new RobotRock(config);
+}
+
+// src/env.ts
+var DEFAULT_BASE_URL = "https://api.robotrock.com/v1";
+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 / client to askHuman."
+    );
+  }
+  const baseUrl = overrides?.baseUrl ?? process.env.ROBOTROCK_BASE_URL ?? process.env.ROBOTROCK_API_URL ?? DEFAULT_BASE_URL;
+  return { apiKey, baseUrl };
+}
+function resolveRobotRockClient(client, configOverrides) {
+  if (client) {
+    return client;
+  }
+  return createClient(resolveRobotRockConfig(configOverrides));
+}
+
+// src/approval-result.ts
+var AskHumanTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AskHumanTimeoutError";
+  }
+};
+var AskHumanExpiredError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AskHumanExpiredError";
+  }
+};
+function toDiscriminatedApprovalResult(actions, task, streamEntryId) {
+  void actions;
+  if (!task.handled) {
+    throw new Error("Task has no handled result");
+  }
+  return {
+    actionId: task.handled.action.id,
+    data: task.handled.action.data,
+    handledBy: task.handled.handledBy,
+    handledAt: new Date(task.handledAt ?? Date.now()),
+    taskId: task.id || streamEntryId
+  };
+}
+
+export {
+  taskContextSchema,
+  RobotRockError,
+  RobotRock,
+  createClient,
+  resolveRobotRockConfig,
+  resolveRobotRockClient,
+  AskHumanTimeoutError,
+  AskHumanExpiredError,
+  toDiscriminatedApprovalResult
+};
+//# sourceMappingURL=chunk-TUQXDKV6.js.map

package/dist/chunk-TUQXDKV6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../core/src/schemas/task.ts","../src/client.ts","../src/env.ts","../src/approval-result.ts"],"sourcesContent":["import { z } from \"zod\";\nimport type { JSONSchema7 } from \"./json-schema.js\";\n\n/**\n * Extended JSONSchema7 type that includes RJSF extensions like enumNames\n */\nexport type ExtendedJSONSchema7 = JSONSchema7 & {\n  enumNames?: string[];\n  [key: string]: unknown;\n};\n\n/**\n * UI Schema for RJSF form customization\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\n// Helper schemas\nconst safeUrlSchema = z\n  .string()\n  .refine((url) => url.startsWith(\"http://\") || url.startsWith(\"https://\"), {\n    message: \"URL must start with http:// or https://\",\n  });\n\n// JSONSchema7 validation\nconst jsonSchema7Schema = z.custom<ExtendedJSONSchema7>(\n  (val) => typeof val === \"object\" && val !== null,\n  { message: \"Must be a valid JSON Schema object\" }\n);\n\n// UiSchema validation\nconst uiSchemaSchema = z.custom<UiSchema>((val) => typeof val === \"object\" && val !== null, {\n  message: \"Must be a valid UiSchema object\",\n});\n\n// Handler schemas (per-action handlers for webhooks, triggers, etc.)\nconst webhookHandlerSchema = z.object({\n  type: z.literal(\"webhook\"),\n  url: safeUrlSchema,\n  headers: z.record(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\n// Action schema with JSONSchema-based feedback and optional handlers\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.unknown()).optional(),\n  // Optional handlers for this action - if present, must have at least 1\n  handlers: z.array(handlerSchema).min(1).optional(),\n});\n\n// UI Field Schema\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.unknown()).optional(),\n    items: z.lazy(() => z.record(uiFieldSchemaSchema)).optional(),\n  })\n  .passthrough();\n\n// Context UI Schema\nconst contextUiSchema = z.record(uiFieldSchemaSchema).optional();\n\n// Context data schema\nconst contextDataSchema = z\n  .object({\n    data: z.record(z.unknown()),\n    ui: contextUiSchema,\n  })\n  .optional();\n\n// Main TaskContext schema\nexport const taskContextSchema = z.object({\n  /** Source application id; omitted tasks are grouped in the default inbox. */\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\n// Type exports\nexport type TaskContextInput = z.input<typeof taskContextSchema>;\nexport type TaskContextOutput = z.output<typeof taskContextSchema>;\nexport type TaskContext = TaskContextOutput;\nexport type SafeUrl = z.infer<typeof safeUrlSchema>;\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 ContextData = z.infer<typeof contextDataSchema>;\nexport type ContextUiSchema = z.infer<typeof contextUiSchema>;\nexport type UiFieldSchema = z.infer<typeof uiFieldSchemaSchema>;\n","import { type TaskContextInput, taskContextSchema } from \"@robotrock/core\";\nimport type { Task, TaskResponse } from \"@robotrock/core\";\n\nexport interface RobotRockConfig {\n  /** Your RobotRock API key */\n  apiKey: string;\n  /**\n   * Base URL for the RobotRock API\n   * @default \"https://api.robotrock.com/v1\"\n   */\n  baseUrl?: string;\n}\n\nexport interface CreateTaskOptions {\n  /** Optional idempotency key to prevent duplicate tasks */\n  idempotencyKey?: string;\n}\n\nexport class RobotRockError extends Error {\n  constructor(\n    message: string,\n    public readonly statusCode: number,\n    public readonly response?: unknown\n  ) {\n    super(message);\n    this.name = \"RobotRockError\";\n  }\n}\n\n/**\n * RobotRock API client for creating and querying human-in-the-loop tasks.\n */\nexport class RobotRock {\n  private readonly apiKey: string;\n  private readonly baseUrl: string;\n\n  constructor(config: RobotRockConfig) {\n    if (!config.apiKey) {\n      throw new Error(\"API key is required\");\n    }\n    this.apiKey = config.apiKey;\n    const rawBase = config.baseUrl ?? \"https://api.robotrock.com/v1\";\n    this.baseUrl = rawBase.replace(/\\/+$/, \"\");\n  }\n\n  async createTask(\n    task: TaskContextInput | Readonly<TaskContextInput>,\n    options?: CreateTaskOptions\n  ): Promise<TaskResponse> {\n    const validation = taskContextSchema.safeParse(task);\n    if (!validation.success) {\n      throw new RobotRockError(\n        `Invalid task: ${validation.error.errors[0]?.message}`,\n        400,\n        validation.error.errors\n      );\n    }\n\n    const headers: Record<string, string> = {\n      \"Content-Type\": \"application/json\",\n      \"X-Api-Key\": this.apiKey,\n    };\n\n    if (options?.idempotencyKey) {\n      headers[\"Idempotency-Key\"] = options.idempotencyKey;\n    }\n\n    const response = await fetch(`${this.baseUrl}/`, {\n      method: \"POST\",\n      headers,\n      body: JSON.stringify(validation.data),\n    });\n\n    const data = await response.json();\n\n    if (!response.ok) {\n      throw new RobotRockError(\n        data.message ?? \"Failed to create task\",\n        response.status,\n        data\n      );\n    }\n\n    return data as TaskResponse;\n  }\n\n  /**\n   * Get a task by Redis stream entry id (returned as `task.streamId` from {@link createTask}).\n   */\n  async getTask(streamEntryId: string): Promise<Task | null> {\n    const response = await fetch(`${this.baseUrl}/tasks/${streamEntryId}`, {\n      method: \"GET\",\n      headers: {\n        \"X-Api-Key\": this.apiKey,\n      },\n    });\n\n    if (response.status === 404) {\n      return null;\n    }\n\n    const data = await response.json();\n\n    if (!response.ok) {\n      throw new RobotRockError(\n        data.message ?? \"Failed to get task\",\n        response.status,\n        data\n      );\n    }\n\n    return data as Task;\n  }\n\n  async cancelTask(taskId: string): Promise<void> {\n    const response = await fetch(`${this.baseUrl}/tasks/${taskId}/cancel`, {\n      method: \"POST\",\n      headers: {\n        \"X-Api-Key\": this.apiKey,\n      },\n    });\n\n    if (!response.ok) {\n      const data = await response.json();\n      throw new RobotRockError(\n        data.message ?? \"Failed to cancel task\",\n        response.status,\n        data\n      );\n    }\n  }\n}\n\nexport function createClient(config: RobotRockConfig): RobotRock {\n  return new RobotRock(config);\n}\n","import { createClient, type RobotRock, type RobotRockConfig } from \"./client.js\";\n\nconst DEFAULT_BASE_URL = \"https://api.robotrock.com/v1\";\n\n/**\n * Read RobotRock client config from environment variables.\n *\n * - `ROBOTROCK_API_KEY` (required when not passed explicitly)\n * - `ROBOTROCK_BASE_URL` or `ROBOTROCK_API_URL` (optional)\n */\nexport function resolveRobotRockConfig(\n  overrides?: Partial<RobotRockConfig>\n): RobotRockConfig {\n  const apiKey = overrides?.apiKey ?? process.env.ROBOTROCK_API_KEY;\n  if (!apiKey) {\n    throw new Error(\n      \"RobotRock API key is required. Set ROBOTROCK_API_KEY or pass apiKey / client to askHuman.\"\n    );\n  }\n\n  const baseUrl =\n    overrides?.baseUrl ??\n    process.env.ROBOTROCK_BASE_URL ??\n    process.env.ROBOTROCK_API_URL ??\n    DEFAULT_BASE_URL;\n\n  return { apiKey, baseUrl };\n}\n\n/** Use an explicit client or create one from env / optional config overrides. */\nexport function resolveRobotRockClient(\n  client?: RobotRock,\n  configOverrides?: Partial<RobotRockConfig>\n): RobotRock {\n  if (client) {\n    return client;\n  }\n  return createClient(resolveRobotRockConfig(configOverrides));\n}\n","import type { DiscriminatedApprovalResult, Task, TaskAction } from \"@robotrock/core\";\n\nexport class AskHumanTimeoutError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"AskHumanTimeoutError\";\n  }\n}\n\nexport class AskHumanExpiredError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"AskHumanExpiredError\";\n  }\n}\n\n/**\n * Map a handled API task to a discriminated approval result.\n * Runtime validation is minimal; TypeScript narrows via `task.actions` at the call site.\n */\nexport function toDiscriminatedApprovalResult<A extends readonly TaskAction[]>(\n  actions: A,\n  task: Task,\n  streamEntryId: string\n): DiscriminatedApprovalResult<A> {\n  void actions;\n\n  if (!task.handled) {\n    throw new Error(\"Task has no handled result\");\n  }\n\n  return {\n    actionId: task.handled.action.id,\n    data: task.handled.action.data,\n    handledBy: task.handled.handledBy,\n    handledAt: new Date(task.handledAt ?? Date.now()),\n    taskId: task.id || streamEntryId,\n  } as DiscriminatedApprovalResult<A>;\n}\n"],"mappings":"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","names":[]}

package/dist/client-BQ-j7q68.d.ts

@@ -0,0 +1,37 @@
+import { TaskContextInput, TaskResponse, Task } from '@robotrock/core';
+
+interface RobotRockConfig {
+    /** Your RobotRock API key */
+    apiKey: string;
+    /**
+     * Base URL for the RobotRock API
+     * @default "https://api.robotrock.com/v1"
+     */
+    baseUrl?: string;
+}
+interface CreateTaskOptions {
+    /** Optional idempotency key to prevent duplicate tasks */
+    idempotencyKey?: string;
+}
+declare class RobotRockError extends Error {
+    readonly statusCode: number;
+    readonly response?: unknown | undefined;
+    constructor(message: string, statusCode: number, response?: unknown | undefined);
+}
+/**
+ * RobotRock API client for creating and querying human-in-the-loop tasks.
+ */
+declare class RobotRock {
+    private readonly apiKey;
+    private readonly baseUrl;
+    constructor(config: RobotRockConfig);
+    createTask(task: TaskContextInput | Readonly<TaskContextInput>, options?: CreateTaskOptions): Promise<TaskResponse>;
+    /**
+     * Get a task by Redis stream entry id (returned as `task.streamId` from {@link createTask}).
+     */
+    getTask(streamEntryId: string): Promise<Task | null>;
+    cancelTask(taskId: string): Promise<void>;
+}
+declare function createClient(config: RobotRockConfig): RobotRock;
+
+export { type CreateTaskOptions as C, type RobotRockConfig as R, RobotRock as a, RobotRockError as b, createClient as c };

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+import { R as RobotRockConfig, a as RobotRock, C as CreateTaskOptions } from './client-BQ-j7q68.js';
+export { b as RobotRockError, c as createClient } from './client-BQ-j7q68.js';
+import { TaskAction, TaskContextInput, DiscriminatedApprovalResult, Task } from '@robotrock/core';
+export { ApprovalResult, DiscriminatedApprovalResult, Handler, InferActionData, Task, TaskAction, TaskContext, TaskContextInput, TaskResponse, TaskResult, TaskStatus, TriggerHandler, TupleElementIndices, WebhookHandler, taskContextSchema } from '@robotrock/core';
+
+/**
+ * Read RobotRock client config from environment variables.
+ *
+ * - `ROBOTROCK_API_KEY` (required when not passed explicitly)
+ * - `ROBOTROCK_BASE_URL` or `ROBOTROCK_API_URL` (optional)
+ */
+declare function resolveRobotRockConfig(overrides?: Partial<RobotRockConfig>): RobotRockConfig;
+/** Use an explicit client or create one from env / optional config overrides. */
+declare function resolveRobotRockClient(client?: RobotRock, configOverrides?: Partial<RobotRockConfig>): RobotRock;
+
+/** Task payload for {@link askHuman}; `actions` must stay a literal tuple for inference. */
+type AskHumanTask<A extends readonly TaskAction[]> = Omit<TaskContextInput, "actions"> & {
+    readonly actions: A;
+};
+type AskHumanParams<A extends readonly TaskAction[]> = {
+    task: AskHumanTask<A>;
+    /** Pre-configured client; when omitted, one is created from env / `apiKey` / `baseUrl`. */
+    client?: RobotRock;
+    apiKey?: string;
+    baseUrl?: string;
+    /** Poll interval while waiting for a human (ms). @default 2000 */
+    pollInterval?: number;
+    /** Max wait time (ms). @default 86400000 (24h) */
+    timeout?: number;
+} & Pick<CreateTaskOptions, "idempotencyKey">;
+/**
+ * Create a human-in-the-loop task and block until someone completes it.
+ *
+ * Uses polling against the RobotRock API. For durable waits inside Trigger.dev,
+ * use `robotrock/trigger` instead.
+ *
+ * The return type is inferred from `task.actions`: `actionId` narrows `data`.
+ */
+declare function askHuman<const A extends readonly TaskAction[]>(params: AskHumanParams<A>): Promise<DiscriminatedApprovalResult<A>>;
+
+declare class AskHumanTimeoutError extends Error {
+    constructor(message: string);
+}
+declare class AskHumanExpiredError extends Error {
+    constructor(message: string);
+}
+/**
+ * Map a handled API task to a discriminated approval result.
+ * Runtime validation is minimal; TypeScript narrows via `task.actions` at the call site.
+ */
+declare function toDiscriminatedApprovalResult<A extends readonly TaskAction[]>(actions: A, task: Task, streamEntryId: string): DiscriminatedApprovalResult<A>;
+
+export { AskHumanExpiredError, type AskHumanParams, type AskHumanTask, AskHumanTimeoutError, CreateTaskOptions, RobotRock, RobotRockConfig, askHuman, resolveRobotRockClient, resolveRobotRockConfig, toDiscriminatedApprovalResult };

package/dist/index.js

@@ -0,0 +1,60 @@
+import {
+  AskHumanExpiredError,
+  AskHumanTimeoutError,
+  RobotRock,
+  RobotRockError,
+  createClient,
+  resolveRobotRockClient,
+  resolveRobotRockConfig,
+  taskContextSchema,
+  toDiscriminatedApprovalResult
+} from "./chunk-TUQXDKV6.js";
+
+// src/ask-human.ts
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
+var DEFAULT_TIMEOUT_MS = 24 * 60 * 60 * 1e3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function askHuman(params) {
+  const {
+    task,
+    client: explicitClient,
+    apiKey,
+    baseUrl,
+    pollInterval = DEFAULT_POLL_INTERVAL_MS,
+    timeout = DEFAULT_TIMEOUT_MS,
+    idempotencyKey
+  } = params;
+  const client = resolveRobotRockClient(explicitClient, { apiKey, baseUrl });
+  const response = await client.createTask(
+    task,
+    { idempotencyKey }
+  );
+  const streamId = response.task.streamId;
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    const existing = await client.getTask(streamId);
+    if (existing?.status === "handled" && existing.handled) {
+      return toDiscriminatedApprovalResult(task.actions, existing, streamId);
+    }
+    if (existing?.status === "expired") {
+      throw new AskHumanExpiredError("Task expired before a human completed it");
+    }
+    await sleep(pollInterval);
+  }
+  throw new AskHumanTimeoutError(`No human response within ${timeout}ms`);
+}
+export {
+  AskHumanExpiredError,
+  AskHumanTimeoutError,
+  RobotRock,
+  RobotRockError,
+  askHuman,
+  createClient,
+  resolveRobotRockClient,
+  resolveRobotRockConfig,
+  taskContextSchema,
+  toDiscriminatedApprovalResult
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/ask-human.ts"],"sourcesContent":["import {\n  AskHumanExpiredError,\n  AskHumanTimeoutError,\n  toDiscriminatedApprovalResult,\n} from \"./approval-result.js\";\nimport type { RobotRock, RobotRockConfig, CreateTaskOptions } from \"./client.js\";\nimport { resolveRobotRockClient } from \"./env.js\";\nimport type {\n  DiscriminatedApprovalResult,\n  TaskAction,\n  TaskContextInput,\n} from \"@robotrock/core\";\n\nconst DEFAULT_POLL_INTERVAL_MS = 2_000;\nconst DEFAULT_TIMEOUT_MS = 24 * 60 * 60 * 1_000;\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n/** Task payload for {@link askHuman}; `actions` must stay a literal tuple for inference. */\nexport type AskHumanTask<A extends readonly TaskAction[]> = Omit<TaskContextInput, \"actions\"> & {\n  readonly actions: A;\n};\n\nexport type AskHumanParams<A extends readonly TaskAction[]> = {\n  task: AskHumanTask<A>;\n  /** Pre-configured client; when omitted, one is created from env / `apiKey` / `baseUrl`. */\n  client?: RobotRock;\n  apiKey?: string;\n  baseUrl?: string;\n  /** Poll interval while waiting for a human (ms). @default 2000 */\n  pollInterval?: number;\n  /** Max wait time (ms). @default 86400000 (24h) */\n  timeout?: number;\n} & Pick<CreateTaskOptions, \"idempotencyKey\">;\n\n/**\n * Create a human-in-the-loop task and block until someone completes it.\n *\n * Uses polling against the RobotRock API. For durable waits inside Trigger.dev,\n * use `robotrock/trigger` instead.\n *\n * The return type is inferred from `task.actions`: `actionId` narrows `data`.\n */\nexport async function askHuman<const A extends readonly TaskAction[]>(\n  params: AskHumanParams<A>\n): Promise<DiscriminatedApprovalResult<A>> {\n  const {\n    task,\n    client: explicitClient,\n    apiKey,\n    baseUrl,\n    pollInterval = DEFAULT_POLL_INTERVAL_MS,\n    timeout = DEFAULT_TIMEOUT_MS,\n    idempotencyKey,\n  } = params;\n\n  const client = resolveRobotRockClient(explicitClient, { apiKey, baseUrl });\n  const response = await client.createTask(\n    task as unknown as TaskContextInput,\n    { idempotencyKey }\n  );\n  const streamId = response.task.streamId;\n  const deadline = Date.now() + timeout;\n\n  while (Date.now() < deadline) {\n    const existing = await client.getTask(streamId);\n\n    if (existing?.status === \"handled\" && existing.handled) {\n      return toDiscriminatedApprovalResult(task.actions, existing, streamId);\n    }\n\n    if (existing?.status === \"expired\") {\n      throw new AskHumanExpiredError(\"Task expired before a human completed it\");\n    }\n\n    await sleep(pollInterval);\n  }\n\n  throw new AskHumanTimeoutError(`No human response within ${timeout}ms`);\n}\n\nexport type { RobotRockConfig };\n"],"mappings":";;;;;;;;;;;;;AAaA,IAAM,2BAA2B;AACjC,IAAM,qBAAqB,KAAK,KAAK,KAAK;AAE1C,SAAS,MAAM,IAA2B;AACxC,SAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,EAAE,CAAC;AACzD;AA2BA,eAAsB,SACpB,QACyC;AACzC,QAAM;AAAA,IACJ;AAAA,IACA,QAAQ;AAAA,IACR;AAAA,IACA;AAAA,IACA,eAAe;AAAA,IACf,UAAU;AAAA,IACV;AAAA,EACF,IAAI;AAEJ,QAAM,SAAS,uBAAuB,gBAAgB,EAAE,QAAQ,QAAQ,CAAC;AACzE,QAAM,WAAW,MAAM,OAAO;AAAA,IAC5B;AAAA,IACA,EAAE,eAAe;AAAA,EACnB;AACA,QAAM,WAAW,SAAS,KAAK;AAC/B,QAAM,WAAW,KAAK,IAAI,IAAI;AAE9B,SAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,UAAM,WAAW,MAAM,OAAO,QAAQ,QAAQ;AAE9C,QAAI,UAAU,WAAW,aAAa,SAAS,SAAS;AACtD,aAAO,8BAA8B,KAAK,SAAS,UAAU,QAAQ;AAAA,IACvE;AAEA,QAAI,UAAU,WAAW,WAAW;AAClC,YAAM,IAAI,qBAAqB,0CAA0C;AAAA,IAC3E;AAEA,UAAM,MAAM,YAAY;AAAA,EAC1B;AAEA,QAAM,IAAI,qBAAqB,4BAA4B,OAAO,IAAI;AACxE;","names":[]}

package/dist/trigger/index.d.ts

@@ -0,0 +1,44 @@
+import { TaskAction, TaskContextInput, DiscriminatedApprovalResult } from '@robotrock/core';
+export { ApprovalResult, DiscriminatedApprovalResult, TaskContextInput, TaskResult } from '@robotrock/core';
+import { a as RobotRock, R as RobotRockConfig } from '../client-BQ-j7q68.js';
+
+/**
+ * JSON body posted by Convex when an action handler runs.
+ * POSTing this to Trigger's `token.url` completes `wait.forToken`.
+ */
+interface RobotRockHandlerWebhookPayload {
+    taskId: string;
+    action: {
+        id: string;
+        title: string;
+        data: unknown;
+    };
+    handledBy?: string;
+    handledAt: string;
+    handlerType: string;
+}
+interface AskHumanTriggerOptions {
+    app?: string;
+    /** Trigger waitpoint timeout (e.g. "1h", "30m", "7d"). @default "24h" */
+    timeout?: string;
+    /** Optional side-channel webhook URL (same payload as the wait token). */
+    callbackUrl?: string;
+}
+type AskHumanTriggerParams<A extends readonly TaskAction[]> = AskHumanTriggerOptions & {
+    task: Omit<TaskContextInput, "actions"> & {
+        readonly actions: A;
+    };
+    client?: RobotRock;
+    apiKey?: string;
+    baseUrl?: string;
+};
+declare function createTriggerClient(config: RobotRockConfig): RobotRock;
+/**
+ * Ask a human inside a Trigger.dev task run (waitpoint token + RobotRock handlers).
+ *
+ * Return type is inferred from `task.actions` (`actionId` narrows `data`).
+ * Must run inside `task({ run })` with `@trigger.dev/sdk` installed.
+ */
+declare function askHuman<const A extends readonly TaskAction[]>(params: AskHumanTriggerParams<A>): Promise<DiscriminatedApprovalResult<A>>;
+
+export { type AskHumanTriggerOptions, type AskHumanTriggerParams, RobotRockConfig, type RobotRockHandlerWebhookPayload, askHuman, createTriggerClient };

package/dist/trigger/index.js

@@ -0,0 +1,106 @@
+import {
+  createClient,
+  resolveRobotRockClient,
+  toDiscriminatedApprovalResult
+} from "../chunk-TUQXDKV6.js";
+
+// src/trigger/index.ts
+import { wait } from "@trigger.dev/sdk/v3";
+function createTriggerClient(config) {
+  return createClient(config);
+}
+async function askHuman(params) {
+  const {
+    task,
+    app,
+    timeout = "24h",
+    callbackUrl,
+    client: explicitClient,
+    apiKey,
+    baseUrl
+  } = params;
+  assertTriggerTimeoutFormat(timeout);
+  const client = resolveRobotRockClient(explicitClient, { apiKey, baseUrl });
+  const token = await wait.createToken({ timeout });
+  const resolvedApp = app ?? task.app;
+  const taskWithHandlers = {
+    ...task,
+    ...resolvedApp !== void 0 ? { app: resolvedApp } : {},
+    actions: task.actions.map((action) => {
+      const waitHandler = {
+        type: "trigger",
+        url: token.url,
+        headers: {},
+        tokenId: token.id
+      };
+      const callbackHandlers = callbackUrl ? [
+        {
+          type: "trigger",
+          url: callbackUrl,
+          headers: {},
+          tokenId: crypto.randomUUID()
+        }
+      ] : [];
+      return {
+        ...action,
+        handlers: [waitHandler, ...action.handlers ?? [], ...callbackHandlers]
+      };
+    })
+  };
+  await client.createTask(taskWithHandlers);
+  const outcome = await wait.forToken(token.id);
+  if (!outcome.ok) {
+    throw new Error(`Human response timeout after ${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(
+    task.actions,
+    {
+      id: output.taskId,
+      createdAt: /* @__PURE__ */ new Date(),
+      status: "handled",
+      context: taskWithHandlers,
+      validUntil: Date.now(),
+      handledAt: new Date(output.handledAt).getTime(),
+      handled: {
+        action: {
+          id: output.action.id,
+          data: output.action.data
+        },
+        handledBy: output.handledBy
+      }
+    },
+    output.taskId
+  );
+}
+function assertTriggerTimeoutFormat(timeout) {
+  const match = timeout.match(/^(\d+)(s|m|h|d)$/);
+  if (!match) {
+    throw new Error(`Invalid timeout format: ${timeout}. Use format like "1h", "30m", "7d"`);
+  }
+}
+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;
+}
+export {
+  askHuman,
+  createTriggerClient
+};
+//# sourceMappingURL=index.js.map

package/dist/trigger/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/trigger/index.ts"],"sourcesContent":["import type {\n  DiscriminatedApprovalResult,\n  TaskAction,\n  TaskContextInput,\n} from \"@robotrock/core\";\nimport { wait } from \"@trigger.dev/sdk/v3\";\nimport { createClient, type RobotRock, type RobotRockConfig } from \"../client.js\";\nimport { resolveRobotRockClient } from \"../env.js\";\nimport { toDiscriminatedApprovalResult } from \"../approval-result.js\";\n\n/**\n * JSON body posted by Convex when an action handler runs.\n * POSTing this to Trigger's `token.url` completes `wait.forToken`.\n */\nexport interface RobotRockHandlerWebhookPayload {\n  taskId: string;\n  action: {\n    id: string;\n    title: string;\n    data: unknown;\n  };\n  handledBy?: string;\n  handledAt: string;\n  handlerType: string;\n}\n\nexport interface AskHumanTriggerOptions {\n  app?: string;\n  /** Trigger waitpoint timeout (e.g. \"1h\", \"30m\", \"7d\"). @default \"24h\" */\n  timeout?: string;\n  /** Optional side-channel webhook URL (same payload as the wait token). */\n  callbackUrl?: string;\n}\n\nexport type AskHumanTriggerParams<A extends readonly TaskAction[]> = AskHumanTriggerOptions & {\n  task: Omit<TaskContextInput, \"actions\"> & { readonly actions: A };\n  client?: RobotRock;\n  apiKey?: string;\n  baseUrl?: string;\n};\n\nexport function createTriggerClient(config: RobotRockConfig): RobotRock {\n  return createClient(config);\n}\n\n/**\n * Ask a human inside a Trigger.dev task run (waitpoint token + RobotRock handlers).\n *\n * Return type is inferred from `task.actions` (`actionId` narrows `data`).\n * Must run inside `task({ run })` with `@trigger.dev/sdk` installed.\n */\nexport async function askHuman<const A extends readonly TaskAction[]>(\n  params: AskHumanTriggerParams<A>\n): Promise<DiscriminatedApprovalResult<A>> {\n  const {\n    task,\n    app,\n    timeout = \"24h\",\n    callbackUrl,\n    client: explicitClient,\n    apiKey,\n    baseUrl,\n  } = params;\n\n  assertTriggerTimeoutFormat(timeout);\n\n  const client = resolveRobotRockClient(explicitClient, { apiKey, baseUrl });\n\n  const token = await wait.createToken({ timeout });\n\n  const resolvedApp = app ?? task.app;\n  const taskWithHandlers: TaskContextInput = {\n    ...task,\n    ...(resolvedApp !== undefined ? { app: resolvedApp } : {}),\n    actions: task.actions.map((action: TaskAction) => {\n      const waitHandler = {\n        type: \"trigger\" as const,\n        url: token.url,\n        headers: {} as Record<string, string>,\n        tokenId: token.id,\n      };\n      const callbackHandlers = callbackUrl\n        ? [\n            {\n              type: \"trigger\" as const,\n              url: callbackUrl,\n              headers: {} as Record<string, string>,\n              tokenId: crypto.randomUUID(),\n            },\n          ]\n        : [];\n\n      return {\n        ...action,\n        handlers: [waitHandler, ...(action.handlers ?? []), ...callbackHandlers],\n      };\n    }),\n  };\n\n  await client.createTask(taskWithHandlers);\n\n  const outcome = await wait.forToken<RobotRockHandlerWebhookPayload>(token.id);\n\n  if (!outcome.ok) {\n    throw new Error(`Human response timeout after ${timeout}`);\n  }\n\n  const output = outcome.output;\n  if (!isRobotRockHandlerWebhookPayload(output)) {\n    throw new Error(\n      \"Wait token completed with unexpected payload; expected RobotRock handler body (taskId, action.id, action.data).\"\n    );\n  }\n\n  return toDiscriminatedApprovalResult(\n    task.actions,\n    {\n      id: output.taskId,\n      createdAt: new Date(),\n      status: \"handled\",\n      context: taskWithHandlers,\n      validUntil: Date.now(),\n      handledAt: new Date(output.handledAt).getTime(),\n      handled: {\n        action: {\n          id: output.action.id,\n          data: output.action.data,\n        },\n        handledBy: output.handledBy,\n      },\n    },\n    output.taskId\n  );\n}\n\nfunction assertTriggerTimeoutFormat(timeout: string): void {\n  const match = timeout.match(/^(\\d+)(s|m|h|d)$/);\n  if (!match) {\n    throw new Error(`Invalid timeout format: ${timeout}. Use format like \"1h\", \"30m\", \"7d\"`);\n  }\n}\n\nfunction isRobotRockHandlerWebhookPayload(\n  value: unknown\n): value is RobotRockHandlerWebhookPayload {\n  if (typeof value !== \"object\" || value === null) {\n    return false;\n  }\n  const v = value as Record<string, unknown>;\n  if (typeof v.taskId !== \"string\" || typeof v.handledAt !== \"string\") {\n    return false;\n  }\n  const action = v.action;\n  if (typeof action !== \"object\" || action === null) {\n    return false;\n  }\n  const a = action as Record<string, unknown>;\n  return typeof a.id === \"string\" && \"data\" in a;\n}\n\nexport type {\n  ApprovalResult,\n  DiscriminatedApprovalResult,\n  TaskContextInput,\n  TaskResult,\n} from \"@robotrock/core\";\nexport type { RobotRockConfig } from \"../client.js\";\n"],"mappings":";;;;;;;AAKA,SAAS,YAAY;AAoCd,SAAS,oBAAoB,QAAoC;AACtE,SAAO,aAAa,MAAM;AAC5B;AAQA,eAAsB,SACpB,QACyC;AACzC,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA,UAAU;AAAA,IACV;AAAA,IACA,QAAQ;AAAA,IACR;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,6BAA2B,OAAO;AAElC,QAAM,SAAS,uBAAuB,gBAAgB,EAAE,QAAQ,QAAQ,CAAC;AAEzE,QAAM,QAAQ,MAAM,KAAK,YAAY,EAAE,QAAQ,CAAC;AAEhD,QAAM,cAAc,OAAO,KAAK;AAChC,QAAM,mBAAqC;AAAA,IACzC,GAAG;AAAA,IACH,GAAI,gBAAgB,SAAY,EAAE,KAAK,YAAY,IAAI,CAAC;AAAA,IACxD,SAAS,KAAK,QAAQ,IAAI,CAAC,WAAuB;AAChD,YAAM,cAAc;AAAA,QAClB,MAAM;AAAA,QACN,KAAK,MAAM;AAAA,QACX,SAAS,CAAC;AAAA,QACV,SAAS,MAAM;AAAA,MACjB;AACA,YAAM,mBAAmB,cACrB;AAAA,QACE;AAAA,UACE,MAAM;AAAA,UACN,KAAK;AAAA,UACL,SAAS,CAAC;AAAA,UACV,SAAS,OAAO,WAAW;AAAA,QAC7B;AAAA,MACF,IACA,CAAC;AAEL,aAAO;AAAA,QACL,GAAG;AAAA,QACH,UAAU,CAAC,aAAa,GAAI,OAAO,YAAY,CAAC,GAAI,GAAG,gBAAgB;AAAA,MACzE;AAAA,IACF,CAAC;AAAA,EACH;AAEA,QAAM,OAAO,WAAW,gBAAgB;AAExC,QAAM,UAAU,MAAM,KAAK,SAAyC,MAAM,EAAE;AAE5E,MAAI,CAAC,QAAQ,IAAI;AACf,UAAM,IAAI,MAAM,gCAAgC,OAAO,EAAE;AAAA,EAC3D;AAEA,QAAM,SAAS,QAAQ;AACvB,MAAI,CAAC,iCAAiC,MAAM,GAAG;AAC7C,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AAAA,IACL,KAAK;AAAA,IACL;AAAA,MACE,IAAI,OAAO;AAAA,MACX,WAAW,oBAAI,KAAK;AAAA,MACpB,QAAQ;AAAA,MACR,SAAS;AAAA,MACT,YAAY,KAAK,IAAI;AAAA,MACrB,WAAW,IAAI,KAAK,OAAO,SAAS,EAAE,QAAQ;AAAA,MAC9C,SAAS;AAAA,QACP,QAAQ;AAAA,UACN,IAAI,OAAO,OAAO;AAAA,UAClB,MAAM,OAAO,OAAO;AAAA,QACtB;AAAA,QACA,WAAW,OAAO;AAAA,MACpB;AAAA,IACF;AAAA,IACA,OAAO;AAAA,EACT;AACF;AAEA,SAAS,2BAA2B,SAAuB;AACzD,QAAM,QAAQ,QAAQ,MAAM,kBAAkB;AAC9C,MAAI,CAAC,OAAO;AACV,UAAM,IAAI,MAAM,2BAA2B,OAAO,qCAAqC;AAAA,EACzF;AACF;AAEA,SAAS,iCACP,OACyC;AACzC,MAAI,OAAO,UAAU,YAAY,UAAU,MAAM;AAC/C,WAAO;AAAA,EACT;AACA,QAAM,IAAI;AACV,MAAI,OAAO,EAAE,WAAW,YAAY,OAAO,EAAE,cAAc,UAAU;AACnE,WAAO;AAAA,EACT;AACA,QAAM,SAAS,EAAE;AACjB,MAAI,OAAO,WAAW,YAAY,WAAW,MAAM;AACjD,WAAO;AAAA,EACT;AACA,QAAM,IAAI;AACV,SAAO,OAAO,EAAE,OAAO,YAAY,UAAU;AAC/C;","names":[]}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "robotrock",
+  "version": "0.1.0",
+  "description": "Human-in-the-loop approval workflows for AI agents",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./trigger": {
+      "types": "./dist/trigger/index.d.ts",
+      "import": "./dist/trigger/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "robotrock",
+    "human-in-the-loop",
+    "approval",
+    "workflow",
+    "trigger.dev"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/robotrock/robotrock"
+  },
+  "dependencies": {
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@robotrock/core": "workspace:*",
+    "@robotrock/config": "workspace:*",
+    "@types/node": "^25.0.3",
+    "@trigger.dev/sdk": "4.4.6",
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@trigger.dev/sdk": "^3.0.0 || ^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@trigger.dev/sdk": {
+      "optional": true
+    }
+  }
+}