robotrock 0.9.0 → 1.1.0

package/dist/index.js

@@ -108,6 +108,25 @@ function isBlockedHostname(hostname) {
   }
   return isBlockedIpv4(host) || isBlockedIpv6(host);
 }
+function isLoopbackHandlerUrl(urlString) {
+  let url;
+  try {
+    url = new URL(urlString);
+  } catch {
+    return false;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    return false;
+  }
+  if (url.username || url.password) {
+    return false;
+  }
+  const host = url.hostname.toLowerCase();
+  return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]" || host.endsWith(".localhost");
+}
+function isAllowedHandlerUrl(urlString) {
+  return isPublicHttpUrl(urlString) || isLoopbackHandlerUrl(urlString);
+}
 function isPublicHttpUrl(urlString) {
   let url;
   try {
@@ -124,6 +143,7 @@ function isPublicHttpUrl(urlString) {
   return !isBlockedHostname(url.hostname);
 }
 var PUBLIC_HTTP_URL_ERROR = "URL must be a public http:// or https:// address";
+var HANDLER_URL_ERROR = "Handler URL must be a public or loopback http:// or https:// address";
 
 // ../core/src/schemas/task.ts
 import { z } from "zod";
@@ -185,6 +205,9 @@ function validateContextPublicUrls(context2) {
 var safeUrlSchema = z.string().refine((url) => isPublicHttpUrl(url), {
   message: PUBLIC_HTTP_URL_ERROR
 });
+var handlerUrlSchema = z.string().refine((url) => isAllowedHandlerUrl(url), {
+  message: HANDLER_URL_ERROR
+});
 var jsonSchema7Schema = z.custom(
   (val) => typeof val === "object" && val !== null,
   { message: "Must be a valid JSON Schema object" }
@@ -194,7 +217,7 @@ var uiSchemaSchema = z.custom((val) => typeof val === "object" && val !== null,
 });
 var webhookHandlerSchema = z.object({
   type: z.literal("webhook"),
-  url: safeUrlSchema,
+  url: handlerUrlSchema,
   headers: z.record(z.string(), z.string())
 });
 var triggerHandlerSchema = webhookHandlerSchema.extend({
@@ -202,13 +225,15 @@ var triggerHandlerSchema = webhookHandlerSchema.extend({
   tokenId: z.string().min(1)
 });
 var handlerSchema = z.discriminatedUnion("type", [webhookHandlerSchema, triggerHandlerSchema]);
-var taskActionSchema = z.object({
+var taskActionInputSchema = 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(),
+  data: z.record(z.string(), z.unknown()).optional()
+});
+var taskActionSchema = taskActionInputSchema.extend({
   // Optional handlers for this action - if present, must have at least 1
   handlers: z.array(handlerSchema).min(1).optional()
 });
@@ -316,10 +341,100 @@ var createTaskBodySchema = taskContextObjectBaseSchema.extend({
   /** Agent release version — not shown in inbox UI. */
   agent: agentTelemetrySchema.optional()
 }).transform(normalizeTaskContextVersion).superRefine(refineContextPublicUrls);
+var agentChatSeedActionSchema = z.object({
+  /** Stable action id echoed back on submit; auto-derived from title when omitted. */
+  id: z.string().min(1).optional(),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  /** JSON Schema object for the form fields. */
+  schema: z.record(z.string(), z.unknown()).optional(),
+  /** RJSF ui schema overrides (ui:widget, ui:enumNames, etc.). */
+  ui: z.record(z.string(), z.unknown()).optional(),
+  /** Optional default field values. */
+  data: z.record(z.string(), z.unknown()).optional()
+});
+var agentChatSeedMessageSchema = z.object({
+  role: z.enum(["user", "assistant"]),
+  text: z.string().min(1),
+  /** Optional display-name override for the message sender. */
+  senderName: z.string().min(1).optional(),
+  /**
+   * Optional structured input request rendered as a styled RobotRock action
+   * widget below the message text. Use this instead of asking the user to reply
+   * in plain text so the request is always a proper action form.
+   */
+  requestActionInput: z.object({
+    prompt: z.string().optional(),
+    action: agentChatSeedActionSchema
+  }).optional()
+});
+var eveAgentChatTransportSchema = z.object({
+  kind: z.literal("eve"),
+  chatId: z.string().min(1),
+  baseUrl: z.string().url(),
+  sessionId: z.string().optional(),
+  continuationToken: z.string().optional(),
+  streamIndex: z.number().int().nonnegative().optional(),
+  isStreaming: z.boolean().optional()
+});
+var createAgentChatBodySchema = z.object({
+  /** Agent id (eve agent name). Required unless `parentChatId` is set. */
+  agentIdentifier: z.string().min(1).optional(),
+  /** Inherit tenant/connection/agent from an existing chat (agent-spawned chats). */
+  parentChatId: z.string().min(1).optional(),
+  /** Convex tenantEveConnections id; resolved from the tenant when omitted. */
+  eveConnectionId: z.string().min(1).optional(),
+  /** Source application id; groups the chat under an inbox section. */
+  app: z.string().min(1).optional(),
+  assignTo: assignToSchema.optional(),
+  title: z.string().min(1),
+  messages: z.array(agentChatSeedMessageSchema).default([]),
+  /** Provenance label stored on the session ("cron" | "agent" | ...). */
+  source: z.string().min(1).optional()
+}).refine((data) => Boolean(data.agentIdentifier || data.parentChatId), {
+  message: "Provide either agentIdentifier or parentChatId"
+});
+var agentChatAuditInputBodySchema = z.object({
+  eveSessionId: z.string().min(1),
+  userId: z.string().min(1),
+  actionId: z.string().min(1),
+  actionTitle: z.string().optional(),
+  prompt: z.string().optional(),
+  data: z.record(z.string(), z.unknown()).optional(),
+  idempotencyKey: z.string().optional(),
+  /** Eve input request id — used to merge staged HITL metadata. */
+  requestId: z.string().optional(),
+  /** Eve tool call id — fallback lookup for staged HITL metadata. */
+  toolCallId: z.string().optional()
+});
+var eveHitlStagedOptionSchema = z.object({
+  id: z.string(),
+  label: z.string()
+});
+var agentChatStageHitlBodySchema = z.object({
+  eveSessionId: z.string().min(1),
+  requests: z.array(
+    z.object({
+      requestId: z.string().min(1),
+      toolCallId: z.string().min(1),
+      toolName: z.string().min(1),
+      prompt: z.string().min(1),
+      display: z.enum(["confirmation", "select", "text"]).optional(),
+      allowFreeform: z.boolean().optional(),
+      options: z.array(eveHitlStagedOptionSchema).optional(),
+      toolInput: z.record(z.string(), z.unknown()).optional()
+    })
+  )
+});
+var agentChatLinkTaskBodySchema = z.object({
+  eveSessionId: z.string().min(1),
+  publicTaskId: z.string().min(1),
+  toolCallId: z.string().min(1)
+});
 
 // src/schemas/index.ts
-var safeUrlSchema2 = z2.string().refine((url) => isPublicHttpUrl(url), {
-  message: PUBLIC_HTTP_URL_ERROR
+var handlerUrlSchema2 = z2.string().refine((url) => isAllowedHandlerUrl(url), {
+  message: HANDLER_URL_ERROR
 });
 var jsonSchema7Schema2 = z2.custom(
   (val) => typeof val === "object" && val !== null,
@@ -330,7 +445,7 @@ var uiSchemaSchema2 = z2.custom((val) => typeof val === "object" && val !== null
 });
 var webhookHandlerSchema2 = z2.object({
   type: z2.literal("webhook"),
-  url: safeUrlSchema2,
+  url: handlerUrlSchema2,
   headers: z2.record(z2.string(), z2.string())
 });
 var triggerHandlerSchema2 = webhookHandlerSchema2.extend({
@@ -338,13 +453,15 @@ var triggerHandlerSchema2 = webhookHandlerSchema2.extend({
   tokenId: z2.string().min(1)
 });
 var handlerSchema2 = z2.discriminatedUnion("type", [webhookHandlerSchema2, triggerHandlerSchema2]);
-var taskActionSchema2 = z2.object({
+var taskActionInputSchema2 = z2.object({
   id: z2.string().min(1),
   title: z2.string().min(1),
   description: z2.string().optional(),
   schema: jsonSchema7Schema2.optional(),
   ui: uiSchemaSchema2.optional(),
-  data: z2.record(z2.string(), z2.unknown()).optional(),
+  data: z2.record(z2.string(), z2.unknown()).optional()
+});
+var taskActionSchema2 = taskActionInputSchema2.extend({
   handlers: z2.array(handlerSchema2).min(1).optional()
 });
 var uiFieldSchemaSchema2 = z2.object({
@@ -485,6 +602,293 @@ function toDiscriminatedApprovalResult(actions, task) {
   };
 }
 
+// src/http.ts
+var RobotRockError = class extends Error {
+  constructor(message, statusCode, response) {
+    super(message);
+    this.statusCode = statusCode;
+    this.response = response;
+    this.name = "RobotRockError";
+  }
+};
+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 record = data;
+    const maybeMessage = record.message;
+    const maybeHint = record.hint;
+    if (typeof maybeMessage === "string" && maybeMessage.trim()) {
+      if (typeof maybeHint === "string" && maybeHint.trim()) {
+        return `${maybeMessage.trim()} ${maybeHint.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;
+}
+
+// ../core/src/handler-retry.ts
+var HANDLER_RETRY_DELAYS_MS = [
+  6e4,
+  // 1m
+  3e5,
+  // 5m
+  18e5,
+  // 30m
+  36e5,
+  // 1h
+  216e5,
+  // 6h
+  864e5,
+  // 24h
+  1728e5
+  // 48h
+];
+var HANDLER_MAX_ATTEMPTS = HANDLER_RETRY_DELAYS_MS.length + 1;
+
+// ../core/src/attribution/index.ts
+import { z as z3 } from "zod";
+
+// ../core/src/app-url.ts
+var PRODUCTION_APP_URL = "https://app.robotrock.io";
+var PRODUCTION_API_URL = "https://api.robotrock.io/v1";
+var DEV_API_URL = "http://localhost:4001/v1";
+var APP_SIGNUP_URL = `${PRODUCTION_APP_URL}/sign-up`;
+function normalizeRobotRockApiBaseUrl(baseUrl) {
+  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  if (trimmed.endsWith("/v1")) {
+    return trimmed;
+  }
+  return `${trimmed}/v1`;
+}
+function getRobotRockApiBaseUrl() {
+  const explicit = process.env.ROBOTROCK_BASE_URL?.trim() || process.env.ROBOTROCK_API_URL?.trim();
+  if (explicit) {
+    return normalizeRobotRockApiBaseUrl(explicit);
+  }
+  if (process.env.NODE_ENV === "production") {
+    return PRODUCTION_API_URL;
+  }
+  return DEV_API_URL;
+}
+
+// ../core/src/attribution/index.ts
+var ATTRIBUTION_COOKIE_MAX_AGE = 60 * 60 * 24 * 90;
+var attributionSchema = z3.object({
+  utmSource: z3.string().optional(),
+  utmMedium: z3.string().optional(),
+  utmCampaign: z3.string().optional(),
+  utmContent: z3.string().optional(),
+  utmTerm: z3.string().optional(),
+  gclid: z3.string().optional(),
+  landingUrl: z3.string().optional(),
+  referrer: z3.string().optional(),
+  capturedAt: z3.number()
+});
+
+// src/auth-headers.ts
+function buildRobotRockAuthHeaders(auth) {
+  if (auth.kind === "apiKey") {
+    return {
+      "X-Api-Key": auth.apiKey
+    };
+  }
+  return {
+    Authorization: `Bearer ${auth.token}`,
+    "X-RobotRock-Tenant-Slug": auth.tenantSlug,
+    "X-RobotRock-Connection-Id": auth.connectionId
+  };
+}
+function resolveRobotRockAuthConfig(overrides) {
+  if (overrides?.agentService) {
+    return {
+      kind: "agentService",
+      ...overrides.agentService
+    };
+  }
+  const apiKey = overrides?.apiKey ?? process.env.ROBOTROCK_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "RobotRock auth is required. Set ROBOTROCK_API_KEY, ROBOTROCK_AGENT_SERVICE_TOKEN with tenant context, or pass auth when creating the client."
+    );
+  }
+  return { kind: "apiKey", apiKey };
+}
+
+// src/chats.ts
+function createChatsApi(config) {
+  const headers = () => ({
+    "Content-Type": "application/json",
+    ...buildRobotRockAuthHeaders(config.auth)
+  });
+  return {
+    async create(input) {
+      const bodyPayload = {
+        ...input,
+        app: input.app ?? config.app,
+        messages: input.messages ?? []
+      };
+      const validation = createAgentChatBodySchema.safeParse(bodyPayload);
+      if (!validation.success) {
+        throw new RobotRockError(
+          `Invalid chat: ${validation.error.issues[0]?.message}`,
+          400,
+          validation.error.issues
+        );
+      }
+      const response = await fetch(`${config.baseUrl}/agent-chats`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(validation.data)
+      });
+      const data = await parseResponseBody(response);
+      if (!response.ok) {
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to create chat"),
+          response.status,
+          data
+        );
+      }
+      const result = data;
+      return { tenantSlug: result.tenantSlug, chats: result.chats };
+    },
+    async close(chatId, options) {
+      if (!chatId) {
+        throw new RobotRockError("chatId is required to close a chat", 400);
+      }
+      const response = await fetch(
+        `${config.baseUrl}/agent-chats/${encodeURIComponent(chatId)}/close`,
+        {
+          method: "POST",
+          headers: headers(),
+          body: JSON.stringify({ reason: options?.reason })
+        }
+      );
+      if (!response.ok) {
+        const data = await parseResponseBody(response);
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to close chat"),
+          response.status,
+          data
+        );
+      }
+    },
+    async stageHitlRequests(input) {
+      const validation = agentChatStageHitlBodySchema.safeParse(input);
+      if (!validation.success) {
+        throw new RobotRockError(
+          `Invalid stage HITL input: ${validation.error.issues[0]?.message}`,
+          400,
+          validation.error.issues
+        );
+      }
+      const response = await fetch(`${config.baseUrl}/agent-chats/stage-hitl`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(validation.data)
+      });
+      if (!response.ok) {
+        const data = await parseResponseBody(response);
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to stage chat HITL requests"),
+          response.status,
+          data
+        );
+      }
+    },
+    async getStagedHitlRequests(eveSessionId) {
+      const trimmed = eveSessionId.trim();
+      if (!trimmed) {
+        throw new RobotRockError("eveSessionId is required", 400);
+      }
+      const url = new URL(`${config.baseUrl}/agent-chats/staged-hitl`);
+      url.searchParams.set("eveSessionId", trimmed);
+      const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: headers()
+      });
+      const data = await parseResponseBody(response);
+      if (!response.ok) {
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to fetch staged chat HITL requests"),
+          response.status,
+          data
+        );
+      }
+      const requests = data.requests;
+      return Array.isArray(requests) ? requests : [];
+    },
+    async logInputSubmission(input) {
+      const validation = agentChatAuditInputBodySchema.safeParse(input);
+      if (!validation.success) {
+        throw new RobotRockError(
+          `Invalid audit input: ${validation.error.issues[0]?.message}`,
+          400,
+          validation.error.issues
+        );
+      }
+      const response = await fetch(`${config.baseUrl}/agent-chats/audit-input`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(validation.data)
+      });
+      if (!response.ok) {
+        const data = await parseResponseBody(response);
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to log chat input submission"),
+          response.status,
+          data
+        );
+      }
+    },
+    async linkTask(input) {
+      const validation = agentChatLinkTaskBodySchema.safeParse(input);
+      if (!validation.success) {
+        throw new RobotRockError(
+          `Invalid link task input: ${validation.error.issues[0]?.message}`,
+          400,
+          validation.error.issues
+        );
+      }
+      const response = await fetch(`${config.baseUrl}/agent-chats/link-task`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(validation.data)
+      });
+      if (!response.ok) {
+        const data = await parseResponseBody(response);
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to link inbox task to chat"),
+          response.status,
+          data
+        );
+      }
+    }
+  };
+}
+
 // src/client.ts
 var DEFAULT_POLL_INTERVAL_MS = 2e3;
 var DEFAULT_TIMEOUT_MS = 24 * 60 * 60 * 1e3;
@@ -522,22 +926,18 @@ function serializeValidUntil(value) {
   }
   throw new RobotRockError("Invalid validUntil: expected a Date or parseable date string", 400);
 }
-var RobotRockError = class extends Error {
-  constructor(message, statusCode, response) {
-    super(message);
-    this.statusCode = statusCode;
-    this.response = response;
-    this.name = "RobotRockError";
-  }
-};
 var RobotRock = class {
-  apiKey;
+  auth;
   baseUrl;
   app;
   agentVersion;
   contextVersion;
   webhook;
   polling;
+  /** Task CRUD: `create`, `get`, `cancel`, `sendUpdate`. */
+  tasks;
+  /** Chat CRUD: `create`, `close`. */
+  chats;
   constructor(config) {
     if (config.webhook && config.polling) {
       throw new Error(
@@ -545,24 +945,42 @@ var RobotRock = class {
       );
     }
     const apiKey = config.apiKey ?? process.env.ROBOTROCK_API_KEY;
-    if (!apiKey) {
+    const agentService = config.agentService;
+    if (apiKey && agentService) {
       throw new Error(
-        "RobotRock API key is required. Set ROBOTROCK_API_KEY or pass apiKey when creating the client."
+        "RobotRock client cannot configure both apiKey and agentService."
       );
     }
-    this.apiKey = apiKey;
-    const rawBase = config.baseUrl ?? "https://api.robotrock.io/v1";
-    this.baseUrl = rawBase.replace(/\/+$/, "");
+    this.auth = resolveRobotRockAuthConfig({
+      ...apiKey ? { apiKey } : {},
+      ...agentService ? { agentService } : {}
+    });
+    this.baseUrl = config.baseUrl ?? getRobotRockApiBaseUrl();
     this.app = config.app;
     this.agentVersion = config.version ?? resolveAgentVersionFromEnv();
     this.contextVersion = config.advanced?.contextVersion ?? TASK_CONTEXT_FORMAT_VERSION2;
     this.webhook = config.webhook;
     this.polling = config.polling ?? {};
+    this.tasks = {
+      create: (task) => this.createTaskRequest(task),
+      get: (taskId) => this.getTaskById(taskId),
+      cancel: (taskId) => this.cancelTaskRequest(taskId),
+      sendUpdate: (input) => this.sendThreadUpdate(input)
+    };
+    this.chats = createChatsApi({
+      baseUrl: this.baseUrl,
+      auth: this.auth,
+      app: this.app
+    });
   }
-  /**
-   * Create a task via POST /v1 without waiting for a human response.
-   */
-  async createTask(task) {
+  authHeaders(extra) {
+    return {
+      "Content-Type": "application/json",
+      ...buildRobotRockAuthHeaders(this.auth),
+      ...extra
+    };
+  }
+  async createTaskRequest(task) {
     const normalizedTask = normalizeSendToHumanInput(task, {
       webhook: this.webhook,
       app: this.app,
@@ -586,13 +1004,9 @@ var RobotRock = class {
         validation.error.issues
       );
     }
-    const headers = {
-      "Content-Type": "application/json",
-      "X-Api-Key": this.apiKey
-    };
-    if (task.idempotencyKey) {
-      headers["Idempotency-Key"] = task.idempotencyKey;
-    }
+    const headers = this.authHeaders(
+      task.idempotencyKey ? { "Idempotency-Key": task.idempotencyKey } : void 0
+    );
     const response = await fetch(`${this.baseUrl}/`, {
       method: "POST",
       headers,
@@ -615,7 +1029,7 @@ var RobotRock = class {
       contextVersion: this.contextVersion,
       agentVersion: this.agentVersion
     });
-    const createdTaskTask = await this.createTask(task);
+    const createdTaskTask = await this.createTaskRequest(task);
     const hasHandlers = normalizedTask.actions.some(
       (action) => Array.isArray(action.handlers) && action.handlers.length > 0
     );
@@ -632,7 +1046,7 @@ var RobotRock = class {
     const deadline = validUntilMs !== void 0 ? Math.min(pollingDeadline, validUntilMs) : pollingDeadline;
     const taskId = createdTaskTask.taskId;
     while (Date.now() < deadline) {
-      const existing = await this.getTask(taskId);
+      const existing = await this.getTaskById(taskId);
       if (existing?.status === "handled" && existing.handled) {
         return {
           mode: "handled",
@@ -654,15 +1068,38 @@ var RobotRock = class {
     }
     throw new TaskTimeoutError(`No human response within ${timeoutMs}ms`);
   }
+  /**
+   * Create a task via POST /v1 without waiting for a human response.
+   * @deprecated Use `client.tasks.create()` instead.
+   */
+  async createTask(task) {
+    return this.tasks.create(task);
+  }
   /**
    * Get a task by public task id (returned as `task.taskId` from {@link sendToHuman}).
+   * @deprecated Use `client.tasks.get()` instead.
    */
   async getTask(taskId) {
+    return this.tasks.get(taskId);
+  }
+  /**
+   * Log a status update against a thread.
+   * @deprecated Use `client.tasks.sendUpdate()` instead.
+   */
+  async sendUpdate(input) {
+    return this.tasks.sendUpdate(input);
+  }
+  /**
+   * Cancel a task by public task id.
+   * @deprecated Use `client.tasks.cancel()` instead.
+   */
+  async cancelTask(taskId) {
+    return this.tasks.cancel(taskId);
+  }
+  async getTaskById(taskId) {
     const response = await fetch(`${this.baseUrl}/tasks/${taskId}`, {
       method: "GET",
-      headers: {
-        "X-Api-Key": this.apiKey
-      }
+      headers: this.authHeaders()
     });
     if (response.status === 404) {
       return null;
@@ -677,11 +1114,11 @@ var RobotRock = class {
     }
     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 }) {
+  async sendThreadUpdate({
+    threadId,
+    message,
+    status
+  }) {
     if (!threadId) {
       throw new RobotRockError("threadId is required to send an update", 400);
     }
@@ -697,10 +1134,7 @@ var RobotRock = class {
       `${this.baseUrl}/threads/${encodeURIComponent(threadId)}/updates`,
       {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-Api-Key": this.apiKey
-        },
+        headers: this.authHeaders(),
         body: JSON.stringify(validation.data)
       }
     );
@@ -714,12 +1148,10 @@ var RobotRock = class {
     }
     return data.update;
   }
-  async cancelTask(taskId) {
+  async cancelTaskRequest(taskId) {
     const response = await fetch(`${this.baseUrl}/tasks/${taskId}/cancel`, {
       method: "POST",
-      headers: {
-        "X-Api-Key": this.apiKey
-      }
+      headers: this.authHeaders()
     });
     if (!response.ok) {
       const data = await parseResponseBody(response);
@@ -773,50 +1205,26 @@ function normalizeSendToHumanInput(task, clientDefaults) {
     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;
-}
 
 // src/env.ts
-var DEFAULT_BASE_URL = "https://api.robotrock.io/v1";
 function resolveRobotRockConfig(overrides) {
+  const agentService = overrides?.agentService;
   const apiKey = overrides?.apiKey ?? process.env.ROBOTROCK_API_KEY;
-  if (!apiKey) {
+  if (agentService && apiKey) {
     throw new Error(
-      "RobotRock API key is required. Set ROBOTROCK_API_KEY or pass apiKey when creating the client."
+      "RobotRock client cannot configure both apiKey and agentService."
     );
   }
-  const baseUrl = overrides?.baseUrl ?? process.env.ROBOTROCK_BASE_URL ?? process.env.ROBOTROCK_API_URL ?? DEFAULT_BASE_URL;
+  const baseUrl = overrides?.baseUrl ?? getRobotRockApiBaseUrl();
   const app = overrides?.app ?? process.env.ROBOTROCK_APP;
+  if (agentService) {
+    return app ? { agentService, baseUrl, app } : { agentService, baseUrl };
+  }
+  if (!apiKey) {
+    throw new Error(
+      "RobotRock API key is required. Set ROBOTROCK_API_KEY or pass agentService when creating the client."
+    );
+  }
   return app ? { apiKey, baseUrl, app } : { apiKey, baseUrl };
 }
 function resolveRobotRockClient(client, configOverrides) {
@@ -917,20 +1325,291 @@ function shouldStopAgentForHandledAction(actionId) {
   return isPlatformTerminalAction(actionId);
 }
 
+// src/eve/input-request.ts
+var EVE_INPUT_SUBMIT_ACTION_ID = "submit";
+var EVE_INPUT_OTHER_CHOICE_ID = "__other__";
+var EVE_INPUT_OTHER_CHOICE_LABEL = "Type your own answer";
+var CONFIRMATION_DEFAULT_OPTIONS = [
+  { id: "approve", label: "Approve", style: "primary" },
+  { id: "deny", label: "Deny", style: "danger" }
+];
+var SELECT_PER_OPTION_THRESHOLD = 6;
+function asRecord(value) {
+  if (value == null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function readStringField(data, key) {
+  const value = data[key];
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function resolveEveInputDisplay(request, toolName) {
+  if (request.display) {
+    return request.display;
+  }
+  if (toolName === "ask_question") {
+    return request.options && request.options.length > 0 ? "select" : "text";
+  }
+  if (request.options && request.options.length > 0) {
+    return "select";
+  }
+  return "confirmation";
+}
+function confirmationActions(request) {
+  const options = request.options && request.options.length > 0 ? request.options : CONFIRMATION_DEFAULT_OPTIONS;
+  return options.map((option) => ({
+    id: option.id,
+    title: option.label,
+    ...option.description ? { description: option.description } : {}
+  }));
+}
+function textSubmitAction(prompt) {
+  return {
+    id: EVE_INPUT_SUBMIT_ACTION_ID,
+    title: "Submit",
+    schema: {
+      type: "object",
+      required: ["answer"],
+      properties: {
+        answer: {
+          type: "string",
+          title: "Your answer"
+        }
+      }
+    },
+    ui: {
+      answer: {
+        "ui:title": prompt.trim() || "Your answer",
+        "ui:widget": "textarea"
+      }
+    }
+  };
+}
+function selectPerOptionActions(options) {
+  return options.map((option) => ({
+    id: option.id,
+    title: option.label,
+    ...option.description ? { description: option.description } : {}
+  }));
+}
+function selectFormAction(request) {
+  const options = request.options ?? [];
+  const allowFreeform = request.allowFreeform === true;
+  const enumValues = options.map((option) => option.id);
+  const enumNames = options.map((option) => option.label);
+  if (allowFreeform) {
+    enumValues.push(EVE_INPUT_OTHER_CHOICE_ID);
+    enumNames.push(EVE_INPUT_OTHER_CHOICE_LABEL);
+  }
+  const properties = {
+    choice: {
+      type: "string",
+      title: "Choose one",
+      enum: enumValues
+    }
+  };
+  if (allowFreeform) {
+    properties.other = {
+      type: "string",
+      title: "Your answer"
+    };
+  }
+  const schema = {
+    type: "object",
+    required: ["choice"],
+    properties
+  };
+  if (allowFreeform) {
+    schema.allOf = [
+      {
+        if: {
+          properties: {
+            choice: { const: EVE_INPUT_OTHER_CHOICE_ID }
+          },
+          required: ["choice"]
+        },
+        then: {
+          required: ["other"],
+          properties: {
+            other: {
+              type: "string",
+              minLength: 1
+            }
+          }
+        }
+      }
+    ];
+  }
+  const ui = {
+    choice: {
+      "ui:widget": "radio",
+      "ui:enumNames": enumNames
+    }
+  };
+  if (allowFreeform) {
+    ui.other = {
+      "ui:placeholder": "Enter your answer"
+    };
+  }
+  return {
+    id: EVE_INPUT_SUBMIT_ACTION_ID,
+    title: "Submit",
+    schema,
+    ui
+  };
+}
+function normalizeEveSelectFormData(data) {
+  const choice = typeof data.choice === "string" ? data.choice.trim() : void 0;
+  if (!choice) {
+    return data;
+  }
+  if (choice === EVE_INPUT_OTHER_CHOICE_ID) {
+    return {
+      choice,
+      ...data.other !== void 0 ? { other: data.other } : {}
+    };
+  }
+  return { choice };
+}
+function eveInputRequestToActions(request, options) {
+  const display = resolveEveInputDisplay(request, options?.toolName);
+  switch (display) {
+    case "confirmation":
+      return confirmationActions(request);
+    case "text":
+      return [textSubmitAction(request.prompt)];
+    case "select": {
+      const selectOptions = request.options ?? [];
+      if (selectOptions.length === 0) {
+        return [textSubmitAction(request.prompt)];
+      }
+      if (selectOptions.length <= SELECT_PER_OPTION_THRESHOLD && request.allowFreeform !== true) {
+        return selectPerOptionActions(selectOptions);
+      }
+      return [selectFormAction(request)];
+    }
+  }
+}
+function eveInputRequestTaskType(request, options) {
+  const display = resolveEveInputDisplay(request, options?.toolName);
+  if (display === "confirmation" && options?.toolName) {
+    return `eve-approval:${options.toolName}`;
+  }
+  return `eve-input:${display}`;
+}
+function taskHandledToEveInputResponse(request, actionId, actionData, options) {
+  const base = { requestId: request.requestId };
+  if (isPlatformTerminalAction(actionId)) {
+    const feedback = parsePlatformRejectRequestData(actionData)?.feedback;
+    return {
+      ...base,
+      optionId: "deny",
+      ...feedback ? { text: feedback } : {}
+    };
+  }
+  const display = resolveEveInputDisplay(request, options?.toolName);
+  const selectOptions = request.options ?? [];
+  const data = asRecord(actionData);
+  if (display === "confirmation") {
+    return { ...base, optionId: actionId };
+  }
+  const matchingOption = selectOptions.find((option) => option.id === actionId);
+  if (matchingOption) {
+    return { ...base, optionId: actionId };
+  }
+  if (actionId === EVE_INPUT_SUBMIT_ACTION_ID && data) {
+    const submissionData = display === "select" && request.allowFreeform === true ? normalizeEveSelectFormData(data) : data;
+    const answer = readStringField(submissionData, "answer");
+    if (answer) {
+      return { ...base, text: answer };
+    }
+    const choice = readStringField(submissionData, "choice");
+    if (choice === EVE_INPUT_OTHER_CHOICE_ID) {
+      const other = readStringField(submissionData, "other");
+      if (other) {
+        return { ...base, text: other };
+      }
+    }
+    if (choice) {
+      if (selectOptions.some((option) => option.id === choice)) {
+        return { ...base, optionId: choice };
+      }
+      return { ...base, text: choice };
+    }
+  }
+  if (data) {
+    const answer = readStringField(data, "answer");
+    if (answer) {
+      return { ...base, text: answer };
+    }
+  }
+  return { ...base, optionId: actionId };
+}
+
+// src/eve/tool-display.ts
+var DEFAULT_TOOL_DISPLAY_LABELS = {
+  refund_charge: "Refund a customer charge",
+  deploy_release: "Deploy a release",
+  get_weather: "Get weather",
+  get_my_access: "Check my access",
+  whoami: "Who am I",
+  create_robotrock_task: "Create a RobotRock task"
+};
+var toolDisplayLabelOverrides = {};
+function setToolDisplayLabelOverrides(overrides) {
+  toolDisplayLabelOverrides = overrides;
+}
+function formatToolName(toolName) {
+  const spaced = toolName.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").trim();
+  if (!spaced) {
+    return "Tool";
+  }
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+function getToolDisplayLabel(toolName) {
+  const trimmed = toolName.trim();
+  if (!trimmed) {
+    return "Tool";
+  }
+  return toolDisplayLabelOverrides[trimmed] ?? DEFAULT_TOOL_DISPLAY_LABELS[trimmed] ?? formatToolName(trimmed);
+}
+function formatEveApprovalTitle(request, toolName) {
+  const display = resolveEveInputDisplay(request, toolName);
+  if (display !== "confirmation" || !toolName) {
+    return request.prompt;
+  }
+  return `Approve: ${getToolDisplayLabel(toolName)}`;
+}
+
+// src/eve/resume-message.ts
+function buildTaskHandledResumeMessage(payload) {
+  const handledBy = payload.handledBy?.trim() || "someone";
+  const actionTitle = payload.action.title.trim();
+  return `RobotRock task ${payload.taskId} was handled: ${actionTitle} by ${handledBy}. Briefly tell the user what was decided and what happens next.`;
+}
+
+// src/eve/index.ts
+var ROBOTROCK_READY_HOOK_SLUG = "robotrock-ready";
+
 // src/webhook.ts
 import { createHmac, timingSafeEqual } from "crypto";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var ROBOTROCK_SIGNATURE_HEADER = "x-robotrock-signature";
-var robotRockWebhookPayloadBodySchema = z3.object({
-  taskId: z3.string().min(1),
-  action: z3.object({
-    id: z3.string().min(1),
-    title: z3.string().min(1),
-    data: z3.unknown()
+var robotRockWebhookPayloadBodySchema = z4.object({
+  taskId: z4.string().min(1),
+  action: z4.object({
+    id: z4.string().min(1),
+    title: z4.string().min(1),
+    data: z4.unknown()
   }),
-  handledBy: z3.string().min(1).optional(),
-  handledAt: z3.string().min(1),
-  handlerType: z3.string().min(1)
+  handledBy: z4.string().min(1).optional(),
+  handledAt: z4.string().min(1),
+  handlerType: z4.string().min(1)
 });
 var RobotRockWebhookError = class extends Error {
   constructor(message, code, details) {
@@ -1216,6 +1895,10 @@ function finishRobotRockHumanWaitOtel(session, handled, outcome) {
 export {
   DEFAULT_TASK_PRIORITY,
   DEFAULT_THREAD_UPDATE_STATUS,
+  DEFAULT_TOOL_DISPLAY_LABELS,
+  EVE_INPUT_OTHER_CHOICE_ID,
+  EVE_INPUT_OTHER_CHOICE_LABEL,
+  EVE_INPUT_SUBMIT_ACTION_ID,
   LOWEST_TASK_PRIORITY,
   PLATFORM_MARK_DONE_ACTION_ID,
   PLATFORM_MARK_DONE_ACTION_TITLE,
@@ -1223,6 +1906,7 @@ export {
   PLATFORM_REJECT_REQUEST_ACTION_TITLE,
   PLATFORM_TERMINAL_ACTION_IDS,
   PlatformRejectRequestError,
+  ROBOTROCK_READY_HOOK_SLUG,
   RobotRock,
   RobotRockError,
   RobotRockWebhookError,
@@ -1230,29 +1914,41 @@ export {
   TASK_PRIORITY_RANK,
   TaskExpiredError,
   TaskTimeoutError,
+  agentChatSeedMessageSchema,
   agentTelemetrySchema2 as agentTelemetrySchema,
   assertNotPlatformRejectRequest,
   assignToSchema2 as assignToSchema,
   attachWebhookToActions,
   beginRobotRockHumanWaitOtel,
+  buildTaskHandledResumeMessage,
   captureRobotRockOtelHandle,
+  createAgentChatBodySchema,
+  createChatsApi,
   createClient,
   createTaskBodySchema2 as createTaskBodySchema,
   endRobotRockHumanWaitSpan,
+  eveInputRequestTaskType,
+  eveInputRequestToActions,
   finishRobotRockHumanWaitOtel,
+  formatEveApprovalTitle,
+  getToolDisplayLabel,
   isPlatformMarkDoneAction,
   isPlatformRejectRequestAction,
   isPlatformTerminalAction,
+  normalizeEveSelectFormData,
   parseHandledOutcome,
   parsePlatformRejectRequestData,
   recordRobotRockHandledToOtel,
+  resolveEveInputDisplay,
   resolveRobotRockClient,
   resolveRobotRockConfig,
+  setToolDisplayLabelOverrides,
   shouldRecordRobotRockOtel,
   shouldStopAgentForHandledAction,
   startRobotRockHumanWaitSpan,
   stripPlatformOtelFields,
   taskContextSchema2 as taskContextSchema,
+  taskHandledToEveInputResponse,
   taskPriorities2 as taskPriorities,
   taskPrioritySchema2 as taskPrioritySchema,
   threadUpdateBodySchema,