robotrock 0.1.0 → 0.3.0

package/dist/workflow-BYeIZgD0.d.ts

@@ -0,0 +1,309 @@
+import * as ai from 'ai';
+import { ToolApprovalResponse } from 'ai';
+import { z } from 'zod';
+import { b as RobotRock, a as SendToHumanInput, S as SendToHumanActionInput } from './client-Dhk9qxhL.js';
+import { DiscriminatedApprovalResult } from './schemas/index.js';
+
+declare const APPROVE_BY_HUMAN_ACTIONS$1: readonly [{
+    readonly id: "approve";
+    readonly title: "Approve";
+}, {
+    readonly id: "decline";
+    readonly title: "Decline";
+}];
+/** How RobotRock waits for a human inside AI SDK tool `execute`. */
+type RobotRockAiMode = "polling" | "trigger" | "workflow";
+/**
+ * Polling: `client.sendToHuman()` blocks until handled (scripts, API routes with long timeout).
+ * Trigger: `sendToHumanTask.triggerAndWait()` uses wait tokens (Trigger.dev workers).
+ * Workflow: `sendToHumanInWorkflow()` uses workflow webhooks (Vercel Workflow).
+ */
+type RobotRockAiPollingContext = {
+    mode?: "polling";
+    client: RobotRock;
+};
+type RobotRockAiTriggerContext = {
+    mode: "trigger";
+    /** Inbox app bucket; falls back to `ROBOTROCK_APP` in the Trigger worker. */
+    app?: string;
+};
+type RobotRockAiWorkflowContext = {
+    mode: "workflow";
+    /** Inbox app bucket; falls back to `ROBOTROCK_APP` in the workflow run. */
+    app?: string;
+};
+type RobotRockAiContext = RobotRockAiPollingContext | RobotRockAiTriggerContext | RobotRockAiWorkflowContext;
+declare function normalizeRobotRockAiContext(clientOrContext: RobotRock | RobotRockAiContext): RobotRockAiContext;
+declare function sendToHumanForAi<A extends readonly SendToHumanActionInput[] = readonly SendToHumanActionInput[]>(context: RobotRockAiContext, payload: SendToHumanInput<A>): Promise<DiscriminatedApprovalResult<A>>;
+declare function approveByHumanForAi(context: RobotRockAiContext, payload: Omit<SendToHumanInput, "actions"> & {
+    app?: string;
+}): Promise<DiscriminatedApprovalResult<typeof APPROVE_BY_HUMAN_ACTIONS$1>>;
+
+type HumanToolResult = {
+    taskId: string;
+    actionId: string;
+    data: unknown;
+    handledBy?: string;
+    handledAt: string;
+    /** Present when action ids are approve/decline (or approve/reject). */
+    approved?: boolean;
+};
+type RobotRockToolCallInfo = {
+    toolName: string;
+    toolCallId: string;
+    input: unknown;
+};
+type RobotRockToolApprovalConfig = {
+    /** Tool names that require RobotRock inbox approval before execution. */
+    tools?: readonly string[];
+    /** Custom predicate when tool names alone are not enough. */
+    when?: (toolCall: RobotRockToolCallInfo) => boolean;
+};
+type FormatToolApprovalTaskOptions = {
+    type?: string;
+    approveActionId?: string;
+    denyActionId?: string;
+};
+type ResolveToolApprovalsOptions = {
+    formatTask?: (toolCall: RobotRockToolCallInfo) => SendToHumanInput;
+    approveActionId?: string;
+    denyActionId?: string;
+};
+type RunWithRobotRockApprovalsOptions<T> = {
+    /** Polling mode (requires `client`). */
+    client?: RobotRock;
+    /** Polling or Trigger mode; use `{ mode: "trigger" }` inside Trigger.dev workers. */
+    context?: RobotRockAiContext;
+    /** Initial messages; updated across approval rounds. */
+    messages?: unknown[];
+    maxRounds?: number;
+    resolveOptions?: ResolveToolApprovalsOptions;
+    generate: (messages: unknown[]) => Promise<T>;
+};
+type ToolApprovalRequestPart = {
+    type: "tool-approval-request";
+    approvalId: string;
+    toolCallId?: string;
+    toolCall?: RobotRockToolCallInfo;
+    isAutomatic?: boolean;
+};
+
+declare const APPROVE_BY_HUMAN_ACTIONS: readonly [{
+    readonly id: "approve";
+    readonly title: "Approve";
+}, {
+    readonly id: "decline";
+    readonly title: "Decline";
+}];
+declare const approveByHumanInputSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodString;
+    contextSummary: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    name: string;
+    type?: string | undefined;
+    contextSummary?: string | undefined;
+}, {
+    description: string;
+    name: string;
+    type?: string | undefined;
+    contextSummary?: string | undefined;
+}>;
+type ApproveByHumanToolOptions = {
+    defaultType?: string;
+    description?: string;
+    toolName?: string;
+};
+type ApproveByHumanToolDurableOptions = ApproveByHumanToolOptions & RobotRockAiContext & {
+    mode: "trigger" | "workflow";
+};
+/**
+ * AI SDK tool with fixed approve/decline actions; blocks until a human decides.
+ *
+ * - `approveByHumanTool(robotrock)` — polling via `client.sendToHuman()` (default).
+ * - `approveByHumanTool({ mode: "trigger", app?: "my-agent" })` — durable wait via Trigger.dev.
+ * - `approveByHumanTool({ mode: "workflow", app?: "my-agent" })` — durable wait via Vercel Workflow.
+ */
+declare function approveByHumanTool(clientOrContext: RobotRock | ApproveByHumanToolDurableOptions, maybeOptions?: ApproveByHumanToolOptions): ai.Tool<{
+    description: string;
+    name: string;
+    type?: string | undefined;
+    contextSummary?: string | undefined;
+}, HumanToolResult>;
+
+declare const sendToHumanToolInputSchema: z.ZodObject<{
+    type: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodObject<{
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        ui: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        ui?: Record<string, unknown> | undefined;
+        data?: Record<string, unknown> | undefined;
+    }, {
+        ui?: Record<string, unknown> | undefined;
+        data?: Record<string, unknown> | undefined;
+    }>>;
+    validUntil: z.ZodOptional<z.ZodString>;
+    assignTo: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        users: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        groups: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        users?: string[] | undefined;
+        groups?: string[] | undefined;
+    }, {
+        users?: string[] | undefined;
+        groups?: string[] | undefined;
+    }>, {
+        users?: string[] | undefined;
+        groups?: string[] | undefined;
+    }, {
+        users?: string[] | undefined;
+        groups?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    name: string;
+    description?: string | undefined;
+    validUntil?: string | undefined;
+    context?: {
+        ui?: Record<string, unknown> | undefined;
+        data?: Record<string, unknown> | undefined;
+    } | undefined;
+    assignTo?: {
+        users?: string[] | undefined;
+        groups?: string[] | undefined;
+    } | undefined;
+}, {
+    type: string;
+    name: string;
+    description?: string | undefined;
+    validUntil?: string | undefined;
+    context?: {
+        ui?: Record<string, unknown> | undefined;
+        data?: Record<string, unknown> | undefined;
+    } | undefined;
+    assignTo?: {
+        users?: string[] | undefined;
+        groups?: string[] | undefined;
+    } | undefined;
+}>;
+type CreateSendToHumanToolOptions<A extends readonly SendToHumanActionInput[] = readonly SendToHumanActionInput[]> = {
+    actions: A;
+    defaultType?: string;
+    description?: string;
+    toolName?: string;
+};
+type CreateSendToHumanToolDurableOptions<A extends readonly SendToHumanActionInput[] = readonly SendToHumanActionInput[]> = CreateSendToHumanToolOptions<A> & RobotRockAiContext & {
+    mode: "trigger" | "workflow";
+};
+/**
+ * AI SDK tool that blocks until a human handles a RobotRock task with developer-defined actions.
+ *
+ * - `createSendToHumanTool(robotrock, options)` — polling (default).
+ * - `createSendToHumanTool({ mode: "trigger", actions: [...], app?: "my-agent" })` — Trigger.dev wait tokens.
+ * - `createSendToHumanTool({ mode: "workflow", actions: [...], app?: "my-agent" })` — Vercel Workflow webhooks.
+ */
+declare function createSendToHumanTool<A extends readonly SendToHumanActionInput[] = readonly SendToHumanActionInput[]>(clientOrOptions: RobotRock | CreateSendToHumanToolDurableOptions<A>, maybeOptions?: CreateSendToHumanToolOptions<A>): ai.Tool<{
+    type: string;
+    name: string;
+    description?: string | undefined;
+    validUntil?: string | undefined;
+    context?: {
+        ui?: Record<string, unknown> | undefined;
+        data?: Record<string, unknown> | undefined;
+    } | undefined;
+    assignTo?: {
+        users?: string[] | undefined;
+        groups?: string[] | undefined;
+    } | undefined;
+}, HumanToolResult>;
+
+type CreateRobotRockAiToolsOptions = {
+    /** @default "polling" when `client` is passed; `"trigger"` or `"workflow"` for durable waits. */
+    mode?: "polling" | "trigger" | "workflow";
+    client?: RobotRock;
+    app?: string;
+};
+/**
+ * Build AI SDK tools for a given RobotRock execution mode.
+ *
+ * @example Polling (Next.js route, scripts)
+ * ```ts
+ * const tools = createRobotRockAiTools({ client: robotrock });
+ * ```
+ *
+ * @example Trigger.dev worker
+ * ```ts
+ * const tools = createRobotRockAiTools({ mode: "trigger", app: "my-agent" });
+ * ```
+ *
+ * @example Vercel Workflow + DurableAgent
+ * ```ts
+ * const tools = createRobotRockAiTools({ mode: "workflow", app: "my-agent" });
+ * ```
+ */
+declare function createRobotRockAiTools(options: CreateRobotRockAiToolsOptions): {
+    context: RobotRockAiContext;
+    approveByHuman: (toolOptions?: ApproveByHumanToolOptions) => ai.Tool<{
+        description: string;
+        name: string;
+        type?: string | undefined;
+        contextSummary?: string | undefined;
+    }, HumanToolResult>;
+    sendToHuman: <A extends readonly SendToHumanActionInput[]>(toolOptions: CreateSendToHumanToolOptions<A>) => ai.Tool<{
+        type: string;
+        name: string;
+        description?: string | undefined;
+        validUntil?: string | undefined;
+        context?: {
+            ui?: Record<string, unknown> | undefined;
+            data?: Record<string, unknown> | undefined;
+        } | undefined;
+        assignTo?: {
+            users?: string[] | undefined;
+            groups?: string[] | undefined;
+        } | undefined;
+    }, HumanToolResult>;
+};
+/** Shorthand for `{ mode: "trigger", app }`. */
+declare function createRobotRockAiTriggerContext(options?: Omit<RobotRockAiTriggerContext, "mode">): RobotRockAiContext;
+/** Shorthand for `{ mode: "workflow", app }`. */
+declare function createRobotRockAiWorkflowContext(options?: Omit<RobotRockAiWorkflowContext, "mode">): RobotRockAiContext;
+
+type RobotRockToolApprovalDecision = "user-approval" | undefined;
+/**
+ * AI SDK 7+: pass the return value to `toolApproval` on `generateText`, `streamText`, or `ToolLoopAgent`.
+ * Returns `'user-approval'` for configured tools so execution pauses until a human responds via RobotRock.
+ */
+declare function createRobotRockToolApproval(config: RobotRockToolApprovalConfig): (options: {
+    toolCall: RobotRockToolCallInfo;
+}) => Promise<RobotRockToolApprovalDecision>;
+/**
+ * AI SDK 5–6: use as `needsApproval` on tool definitions (or via {@link applyRobotRockToolApprovalToTools}).
+ */
+declare function createRobotRockNeedsApproval(config: RobotRockToolApprovalConfig): (_input: unknown, options: {
+    toolCallId: string;
+    messages?: unknown[];
+}) => Promise<boolean>;
+/**
+ * AI SDK 5–6: merge `needsApproval` into each matching tool in a tools object.
+ */
+declare function applyRobotRockToolApprovalToTools<T extends Record<string, object>>(tools: T, config: RobotRockToolApprovalConfig): T;
+declare function collectApprovalRequests(source: unknown): ToolApprovalRequestPart[];
+/**
+ * Create RobotRock tasks for pending AI SDK tool approvals and return `tool-approval-response` parts.
+ */
+declare function resolveToolApprovalsViaRobotRock(clientOrContext: RobotRock | RobotRockAiContext, source: unknown, options?: ResolveToolApprovalsOptions): Promise<{
+    responses: ToolApprovalResponse[];
+    messages: unknown[];
+}>;
+/**
+ * Run `generate` in a loop until manual tool approvals are resolved via RobotRock or `maxRounds` is reached.
+ */
+declare function runWithRobotRockApprovals<T>(options: RunWithRobotRockApprovalsOptions<T>): Promise<T>;
+
+export { APPROVE_BY_HUMAN_ACTIONS as A, type ResolveToolApprovalsOptions as B, type CreateSendToHumanToolOptions as C, type RobotRockToolApprovalConfig as D, type RunWithRobotRockApprovalsOptions as E, type FormatToolApprovalTaskOptions as F, type HumanToolResult as H, type RobotRockToolCallInfo as R, type ToolApprovalRequestPart as T, approveByHumanTool as a, approveByHumanInputSchema as b, type ApproveByHumanToolOptions as c, type ApproveByHumanToolDurableOptions as d, createSendToHumanTool as e, type CreateSendToHumanToolDurableOptions as f, approveByHumanForAi as g, sendToHumanForAi as h, type RobotRockAiContext as i, type RobotRockAiMode as j, type RobotRockAiPollingContext as k, type RobotRockAiTriggerContext as l, type RobotRockAiWorkflowContext as m, normalizeRobotRockAiContext as n, createRobotRockAiTools as o, createRobotRockAiTriggerContext as p, createRobotRockAiWorkflowContext as q, type CreateRobotRockAiToolsOptions as r, sendToHumanToolInputSchema as s, applyRobotRockToolApprovalToTools as t, collectApprovalRequests as u, createRobotRockNeedsApproval as v, createRobotRockToolApproval as w, resolveToolApprovalsViaRobotRock as x, runWithRobotRockApprovals as y, type RobotRockToolApprovalDecision as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "robotrock",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Human-in-the-loop approval workflows for AI agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -14,6 +14,22 @@
     "./trigger": {
       "types": "./dist/trigger/index.d.ts",
       "import": "./dist/trigger/index.js"
+    },
+    "./ai": {
+      "types": "./dist/ai/index.d.ts",
+      "import": "./dist/ai/index.js"
+    },
+    "./ai/trigger": {
+      "types": "./dist/ai/trigger.d.ts",
+      "import": "./dist/ai/trigger.js"
+    },
+    "./workflow": {
+      "types": "./dist/workflow/index.d.ts",
+      "import": "./dist/workflow/index.js"
+    },
+    "./ai/workflow": {
+      "types": "./dist/ai/workflow.d.ts",
+      "import": "./dist/ai/workflow.js"
     }
   },
   "files": [
@@ -24,7 +40,8 @@
     "build": "tsup",
     "dev": "tsup --watch",
     "typecheck": "tsc --noEmit",
-    "lint": "eslint src/",
+    "test": "vitest run",
+    "lint": "eslint .",
     "clean": "rm -rf dist"
   },
   "keywords": [
@@ -32,30 +49,43 @@
     "human-in-the-loop",
     "approval",
     "workflow",
-    "trigger.dev"
+    "trigger.dev",
+    "vercel-ai-sdk",
+    "ai-sdk"
   ],
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/robotrock/robotrock"
+    "url": "git+https://github.com/robotrock/robotrock.git"
   },
   "dependencies": {
     "zod": "^3.25.0"
   },
   "devDependencies": {
-    "@robotrock/core": "workspace:*",
     "@robotrock/config": "workspace:*",
-    "@types/node": "^25.0.3",
+    "@robotrock/core": "workspace:*",
     "@trigger.dev/sdk": "4.4.6",
+    "@types/node": "^25.0.3",
+    "ai": "^6.0.196",
+    "eslint": "^9.39.2",
     "tsup": "^8.0.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "workflow": "^4.3.1"
   },
   "peerDependencies": {
-    "@trigger.dev/sdk": "^3.0.0 || ^4.0.0"
+    "@trigger.dev/sdk": "^3.0.0 || ^4.0.0",
+    "ai": "^5.0.0 || ^6.0.0 || ^7.0.0",
+    "workflow": "^4.0.0"
   },
   "peerDependenciesMeta": {
     "@trigger.dev/sdk": {
       "optional": true
+    },
+    "ai": {
+      "optional": true
+    },
+    "workflow": {
+      "optional": true
     }
   }
 }

package/dist/chunk-TUQXDKV6.js

@@ -1,209 +0,0 @@
-// ../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

@@ -1 +0,0 @@
-{"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

@@ -1,37 +0,0 @@
-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 };