robotrock 1.0.0 → 1.1.0

package/dist/trigger/index.js

@@ -305,6 +305,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 {
@@ -321,6 +340,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";
@@ -382,6 +402,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" }
@@ -391,7 +414,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({
@@ -542,13 +565,22 @@ var agentChatSeedMessageSchema = z.object({
     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({
-  /** Trigger chat agent id (task slug). Required unless `parentChatId` is set. */
+  /** 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 tenantTriggerConnections id; resolved from the tenant when omitted. */
-  connectionId: 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(),
@@ -559,16 +591,47 @@ var createAgentChatBodySchema = z.object({
 }).refine((data) => Boolean(data.agentIdentifier || data.parentChatId), {
   message: "Provide either agentIdentifier or parentChatId"
 });
-var agentChatTransportBodySchema = z.object({
-  chatId: z.string().min(1),
-  publicAccessToken: z.string().min(1),
-  lastEventId: z.string().optional(),
-  isStreaming: z.boolean().optional()
+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,
@@ -579,7 +642,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({
@@ -756,8 +819,13 @@ async function parseResponseBody(response) {
 }
 function getErrorMessage(data, fallback) {
   if (data && typeof data === "object" && !Array.isArray(data)) {
-    const maybeMessage = data.message;
+    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;
     }
   }
@@ -793,7 +861,26 @@ 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;
@@ -809,11 +896,40 @@ var attributionSchema = z3.object({
   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",
-    "X-Api-Key": config.apiKey
+    ...buildRobotRockAuthHeaders(config.auth)
   });
   return {
     async create(input) {
@@ -866,6 +982,97 @@ function createChatsApi(config) {
           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
+        );
+      }
     }
   };
 }
@@ -908,7 +1115,7 @@ function serializeValidUntil(value) {
   throw new RobotRockError("Invalid validUntil: expected a Date or parseable date string", 400);
 }
 var RobotRock = class {
-  apiKey;
+  auth;
   baseUrl;
   app;
   agentVersion;
@@ -926,14 +1133,17 @@ 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;
@@ -947,10 +1157,17 @@ var RobotRock = class {
     };
     this.chats = createChatsApi({
       baseUrl: this.baseUrl,
-      apiKey: this.apiKey,
+      auth: this.auth,
       app: this.app
     });
   }
+  authHeaders(extra) {
+    return {
+      "Content-Type": "application/json",
+      ...buildRobotRockAuthHeaders(this.auth),
+      ...extra
+    };
+  }
   async createTaskRequest(task2) {
     const normalizedTask = normalizeSendToHumanInput(task2, {
       webhook: this.webhook,
@@ -975,13 +1192,9 @@ var RobotRock = class {
         validation.error.issues
       );
     }
-    const headers = {
-      "Content-Type": "application/json",
-      "X-Api-Key": this.apiKey
-    };
-    if (task2.idempotencyKey) {
-      headers["Idempotency-Key"] = task2.idempotencyKey;
-    }
+    const headers = this.authHeaders(
+      task2.idempotencyKey ? { "Idempotency-Key": task2.idempotencyKey } : void 0
+    );
     const response = await fetch(`${this.baseUrl}/`, {
       method: "POST",
       headers,
@@ -1074,9 +1287,7 @@ var RobotRock = class {
   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;
@@ -1111,10 +1322,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)
       }
     );
@@ -1131,9 +1339,7 @@ var RobotRock = class {
   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);
@@ -1189,16 +1395,24 @@ function normalizeSendToHumanInput(task2, clientDefaults) {
 }
 
 // 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 };
 }