robotrock 1.0.0 → 1.1.0

package/dist/ai/index.d.ts

@@ -1,10 +1,10 @@
-import { C as CloseChatToolDurableOptions, a as CloseChatToolOptions, c as closeChatToolInputSchema, b as CloseChatToolResult } from '../trigger-BCKBbAV7.js';
-export { d as CLOSE_CHAT_TOOL_NAME, e as CloseChatToolInput, f as CreateRobotRockAiToolsOptions, R as RobotRockAiTools, g as approveByHumanTool, h as createRobotRockAiTools, i as createSendToHumanTool, j as createSendUpdateTool, r as reportStatusTool, k as requestActionInputTool } from '../trigger-BCKBbAV7.js';
+import { C as CloseChatToolDurableOptions, a as CloseChatToolOptions, c as closeChatToolInputSchema, b as CloseChatToolResult } from '../trigger-Dn0DFiyU.js';
+export { d as CLOSE_CHAT_TOOL_NAME, e as CloseChatToolInput, f as CreateRobotRockAiToolsOptions, R as RobotRockAiTools, g as approveByHumanTool, h as createRobotRockAiTools, i as createSendToHumanTool, j as createSendUpdateTool, r as reportStatusTool, k as requestActionInputTool } from '../trigger-Dn0DFiyU.js';
 import { Tool } from 'ai';
 import { z } from 'zod';
-import { R as RobotRock, a as SendToHumanInput } from '../client-CzVmjXpz.js';
-import { u as RobotRockToolCallInfo, F as FormatToolApprovalTaskOptions, H as HumanToolResult } from '../tool-approval-bridge-DbwUEBHv.js';
-export { v as APPROVE_BY_HUMAN_ACTIONS, A as ApproveByHumanToolDurableOptions, a as ApproveByHumanToolOptions, i as CreateSendToHumanToolDurableOptions, C as CreateSendToHumanToolOptions, j as CreateSendUpdateToolDurableOptions, c as CreateSendUpdateToolOptions, w as REPORT_STATUS_TOOL_NAME, x as REQUEST_ACTION_INPUT_TOOL_NAME, y as ReportStatusPhase, z as ReportStatusToolInput, g as ReportStatusToolOptions, B as ReportStatusToolOutput, D as RequestActionInputToolInput, e as RequestActionInputToolOptions, E as RequestActionInputToolOutput, G as ResolveToolApprovalsOptions, k as RobotRockAiContext, l as RobotRockAiMode, m as RobotRockAiPollingContext, n as RobotRockAiTriggerContext, R as RobotRockAiWorkflowContext, I as RobotRockToolApprovalConfig, J as RobotRockToolApprovalDecision, K as RunWithRobotRockApprovalsOptions, L as SendUpdateToolResult, T as ToolApprovalRequestPart, o as applyRobotRockToolApprovalToTools, M as approveByHumanForAi, N as approveByHumanInputSchema, O as buildReportStatusToolDefinition, P as buildRequestActionInputToolDefinition, Q as closeChatForAi, U as collectApprovalRequests, V as createRobotRockAiTriggerContext, p as createRobotRockAiWorkflowContext, q as createRobotRockNeedsApproval, r as createRobotRockToolApproval, W as defaultRequestActionInputActionId, X as executeReportStatusTool, Y as isReportStatusToolPart, Z as isRequestActionInputToolPart, _ as normalizeReportStatusToolInput, $ as normalizeRequestActionInputToolInput, a0 as normalizeRobotRockAiContext, a1 as reportStatusPhaseSchema, a2 as reportStatusToolInputSchema, a3 as reportStatusToolOutputSchema, a4 as requestActionInputToolInputSchema, a5 as requestActionInputToolOutputSchema, s as resolveToolApprovalsViaRobotRock, t as runWithRobotRockApprovals, a6 as sendToHumanForAi, a7 as sendToHumanToolInputSchema, a8 as sendUpdateForAi, a9 as sendUpdateToolInputSchema } from '../tool-approval-bridge-DbwUEBHv.js';
+import { R as RobotRock, a as SendToHumanInput } from '../client-XTnFHGFE.js';
+import { u as RobotRockToolCallInfo, F as FormatToolApprovalTaskOptions, H as HumanToolResult } from '../tool-approval-bridge-C4bTm8vu.js';
+export { v as APPROVE_BY_HUMAN_ACTIONS, A as ApproveByHumanToolDurableOptions, a as ApproveByHumanToolOptions, i as CreateSendToHumanToolDurableOptions, C as CreateSendToHumanToolOptions, j as CreateSendUpdateToolDurableOptions, c as CreateSendUpdateToolOptions, w as REPORT_STATUS_TOOL_NAME, x as REQUEST_ACTION_INPUT_TOOL_NAME, y as ReportStatusPhase, z as ReportStatusToolInput, g as ReportStatusToolOptions, B as ReportStatusToolOutput, D as RequestActionInputToolInput, e as RequestActionInputToolOptions, E as RequestActionInputToolOutput, G as ResolveToolApprovalsOptions, k as RobotRockAiContext, l as RobotRockAiMode, m as RobotRockAiPollingContext, n as RobotRockAiTriggerContext, R as RobotRockAiWorkflowContext, I as RobotRockToolApprovalConfig, J as RobotRockToolApprovalDecision, K as RunWithRobotRockApprovalsOptions, L as SendUpdateToolResult, T as ToolApprovalRequestPart, o as applyRobotRockToolApprovalToTools, M as approveByHumanForAi, N as approveByHumanInputSchema, O as buildReportStatusToolDefinition, P as buildRequestActionInputToolDefinition, Q as closeChatForAi, U as collectApprovalRequests, V as createRobotRockAiTriggerContext, p as createRobotRockAiWorkflowContext, q as createRobotRockNeedsApproval, r as createRobotRockToolApproval, W as defaultRequestActionInputActionId, X as executeReportStatusTool, Y as isReportStatusToolPart, Z as isRequestActionInputToolPart, _ as normalizeReportStatusToolInput, $ as normalizeRequestActionInputToolInput, a0 as normalizeRobotRockAiContext, a1 as reportStatusPhaseSchema, a2 as reportStatusToolInputSchema, a3 as reportStatusToolOutputSchema, a4 as requestActionInputToolInputSchema, a5 as requestActionInputToolOutputSchema, s as resolveToolApprovalsViaRobotRock, t as runWithRobotRockApprovals, a6 as sendToHumanForAi, a7 as sendToHumanToolInputSchema, a8 as sendUpdateForAi, a9 as sendUpdateToolInputSchema } from '../tool-approval-bridge-C4bTm8vu.js';
 import { DiscriminatedApprovalResult } from '../schemas/index.js';
 import '@robotrock/core';
 

package/dist/ai/index.js

@@ -75,6 +75,13 @@ var init_convex_sanitize = __esm({
   }
 });
 
+// ../core/src/utils/deployment-secret-encryption.ts
+var init_deployment_secret_encryption = __esm({
+  "../core/src/utils/deployment-secret-encryption.ts"() {
+    "use strict";
+  }
+});
+
 // ../core/src/utils/safe-url.ts
 function normalizeHostname(hostname) {
   return hostname.toLowerCase().replace(/^\[|\]$/g, "");
@@ -177,6 +184,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 {
@@ -192,7 +218,7 @@ function isPublicHttpUrl(urlString) {
   }
   return !isBlockedHostname(url.hostname);
 }
-var BLOCKED_HOSTNAMES, PUBLIC_HTTP_URL_ERROR;
+var BLOCKED_HOSTNAMES, PUBLIC_HTTP_URL_ERROR, HANDLER_URL_ERROR;
 var init_safe_url = __esm({
   "../core/src/utils/safe-url.ts"() {
     "use strict";
@@ -202,6 +228,7 @@ var init_safe_url = __esm({
       "metadata.goog"
     ]);
     PUBLIC_HTTP_URL_ERROR = "URL must be a public http:// or https:// address";
+    HANDLER_URL_ERROR = "Handler URL must be a public or loopback http:// or https:// address";
   }
 });
 
@@ -218,6 +245,7 @@ var init_utils = __esm({
     "use strict";
     init_cn();
     init_convex_sanitize();
+    init_deployment_secret_encryption();
     init_safe_url();
     init_task_app();
   }
@@ -301,7 +329,7 @@ function refineContextPublicUrls(data, ctx) {
     });
   }
 }
-var safeUrlSchema, jsonSchema7Schema, uiSchemaSchema, webhookHandlerSchema, triggerHandlerSchema, handlerSchema, taskActionInputSchema, taskActionSchema, uiFieldSchemaSchema, contextUiSchema, contextDataSchema, TASK_CONTEXT_FORMAT_VERSION, taskContextObjectBaseSchema, taskContextObjectSchema, taskContextSchema, assignToSchema, threadUpdateMessageSchema, threadUpdateStatuses, threadUpdateStatusSchema, threadUpdateInputSchema, taskPriorities, taskPrioritySchema, agentTelemetrySchema, createTaskBodySchema, agentChatSeedActionSchema, agentChatSeedMessageSchema, createAgentChatBodySchema, agentChatTransportBodySchema;
+var safeUrlSchema, handlerUrlSchema, jsonSchema7Schema, uiSchemaSchema, webhookHandlerSchema, triggerHandlerSchema, handlerSchema, taskActionInputSchema, taskActionSchema, uiFieldSchemaSchema, contextUiSchema, contextDataSchema, TASK_CONTEXT_FORMAT_VERSION, taskContextObjectBaseSchema, taskContextObjectSchema, taskContextSchema, assignToSchema, threadUpdateMessageSchema, threadUpdateStatuses, threadUpdateStatusSchema, threadUpdateInputSchema, taskPriorities, taskPrioritySchema, agentTelemetrySchema, createTaskBodySchema, agentChatSeedActionSchema, agentChatSeedMessageSchema, eveAgentChatTransportSchema, createAgentChatBodySchema, agentChatAuditInputBodySchema, eveHitlStagedOptionSchema, agentChatStageHitlBodySchema, agentChatLinkTaskBodySchema;
 var init_task = __esm({
   "../core/src/schemas/task.ts"() {
     "use strict";
@@ -310,6 +338,9 @@ var init_task = __esm({
     safeUrlSchema = z.string().refine((url) => isPublicHttpUrl(url), {
       message: PUBLIC_HTTP_URL_ERROR
     });
+    handlerUrlSchema = z.string().refine((url) => isAllowedHandlerUrl(url), {
+      message: HANDLER_URL_ERROR
+    });
     jsonSchema7Schema = z.custom(
       (val) => typeof val === "object" && val !== null,
       { message: "Must be a valid JSON Schema object" }
@@ -319,7 +350,7 @@ var init_task = __esm({
     });
     webhookHandlerSchema = z.object({
       type: z.literal("webhook"),
-      url: safeUrlSchema,
+      url: handlerUrlSchema,
       headers: z.record(z.string(), z.string())
     });
     triggerHandlerSchema = webhookHandlerSchema.extend({
@@ -453,13 +484,22 @@ var init_task = __esm({
         action: agentChatSeedActionSchema
       }).optional()
     });
+    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()
+    });
     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(),
@@ -470,11 +510,42 @@ var init_task = __esm({
     }).refine((data) => Boolean(data.agentIdentifier || data.parentChatId), {
       message: "Provide either agentIdentifier or parentChatId"
     });
-    agentChatTransportBodySchema = z.object({
-      chatId: z.string().min(1),
-      publicAccessToken: z.string().min(1),
-      lastEventId: z.string().optional(),
-      isStreaming: z.boolean().optional()
+    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()
+    });
+    eveHitlStagedOptionSchema = z.object({
+      id: z.string(),
+      label: z.string()
+    });
+    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()
+        })
+      )
+    });
+    agentChatLinkTaskBodySchema = z.object({
+      eveSessionId: z.string().min(1),
+      publicTaskId: z.string().min(1),
+      toolCallId: z.string().min(1)
     });
   }
 });
@@ -515,14 +586,14 @@ function refineContextPublicUrls2(data, ctx) {
     });
   }
 }
-var safeUrlSchema2, jsonSchema7Schema2, uiSchemaSchema2, webhookHandlerSchema2, triggerHandlerSchema2, handlerSchema2, taskActionInputSchema2, taskActionSchema2, uiFieldSchemaSchema2, contextUiSchema2, contextDataSchema2, TASK_CONTEXT_FORMAT_VERSION2, taskContextObjectBaseSchema2, taskContextObjectSchema2, taskContextSchema2, assignToSchema2, threadUpdateMessageSchema2, threadUpdateStatuses2, threadUpdateStatusSchema2, threadUpdateInputSchema2, taskPriorities2, taskPrioritySchema2, agentTelemetrySchema2, createTaskBodySchema2, threadUpdateBodySchema;
+var handlerUrlSchema2, jsonSchema7Schema2, uiSchemaSchema2, webhookHandlerSchema2, triggerHandlerSchema2, handlerSchema2, taskActionInputSchema2, taskActionSchema2, uiFieldSchemaSchema2, contextUiSchema2, contextDataSchema2, TASK_CONTEXT_FORMAT_VERSION2, taskContextObjectBaseSchema2, taskContextObjectSchema2, taskContextSchema2, assignToSchema2, threadUpdateMessageSchema2, threadUpdateStatuses2, threadUpdateStatusSchema2, threadUpdateInputSchema2, taskPriorities2, taskPrioritySchema2, agentTelemetrySchema2, createTaskBodySchema2, threadUpdateBodySchema;
 var init_schemas2 = __esm({
   "src/schemas/index.ts"() {
     "use strict";
     init_utils();
     init_schemas();
-    safeUrlSchema2 = z2.string().refine((url) => isPublicHttpUrl(url), {
-      message: PUBLIC_HTTP_URL_ERROR
+    handlerUrlSchema2 = z2.string().refine((url) => isAllowedHandlerUrl(url), {
+      message: HANDLER_URL_ERROR
     });
     jsonSchema7Schema2 = z2.custom(
       (val) => typeof val === "object" && val !== null,
@@ -533,7 +604,7 @@ var init_schemas2 = __esm({
     });
     webhookHandlerSchema2 = z2.object({
       type: z2.literal("webhook"),
-      url: safeUrlSchema2,
+      url: handlerUrlSchema2,
       headers: z2.record(z2.string(), z2.string())
     });
     triggerHandlerSchema2 = webhookHandlerSchema2.extend({
@@ -693,8 +764,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;
     }
   }
@@ -790,11 +866,30 @@ var init_welcome_task = __esm({
 });
 
 // ../core/src/app-url.ts
-var PRODUCTION_APP_URL, APP_SIGNUP_URL;
+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;
+}
+var PRODUCTION_APP_URL, PRODUCTION_API_URL, DEV_API_URL, APP_SIGNUP_URL;
 var init_app_url = __esm({
   "../core/src/app-url.ts"() {
     "use strict";
     PRODUCTION_APP_URL = "https://app.robotrock.io";
+    PRODUCTION_API_URL = "https://api.robotrock.io/v1";
+    DEV_API_URL = "http://localhost:4001/v1";
     APP_SIGNUP_URL = `${PRODUCTION_APP_URL}/sign-up`;
   }
 });
@@ -822,6 +917,13 @@ var init_attribution = __esm({
   }
 });
 
+// ../core/src/agent-service-auth.ts
+var init_agent_service_auth = __esm({
+  "../core/src/agent-service-auth.ts"() {
+    "use strict";
+  }
+});
+
 // ../core/src/index.ts
 var init_src = __esm({
   "../core/src/index.ts"() {
@@ -835,6 +937,41 @@ var init_src = __esm({
     init_welcome_task();
     init_attribution();
     init_app_url();
+    init_agent_service_auth();
+  }
+});
+
+// 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 };
+}
+var init_auth_headers = __esm({
+  "src/auth-headers.ts"() {
+    "use strict";
   }
 });
 
@@ -842,7 +979,7 @@ var init_src = __esm({
 function createChatsApi(config) {
   const headers = () => ({
     "Content-Type": "application/json",
-    "X-Api-Key": config.apiKey
+    ...buildRobotRockAuthHeaders(config.auth)
   });
   return {
     async create(input) {
@@ -895,6 +1032,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
+        );
+      }
     }
   };
 }
@@ -903,6 +1131,7 @@ var init_chats = __esm({
     "use strict";
     init_src();
     init_http();
+    init_auth_headers();
   }
 });
 
@@ -990,12 +1219,14 @@ var init_client = __esm({
     init_schemas2();
     init_approval_result();
     init_http();
+    init_src();
     init_chats();
+    init_auth_headers();
     init_http();
     DEFAULT_POLL_INTERVAL_MS = 2e3;
     DEFAULT_TIMEOUT_MS = 24 * 60 * 60 * 1e3;
     RobotRock = class {
-      apiKey;
+      auth;
       baseUrl;
       app;
       agentVersion;
@@ -1013,14 +1244,17 @@ var init_client = __esm({
           );
         }
         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;
@@ -1034,10 +1268,17 @@ var init_client = __esm({
         };
         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,
@@ -1062,13 +1303,9 @@ var init_client = __esm({
             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,
@@ -1161,9 +1398,7 @@ var init_client = __esm({
       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;
@@ -1198,10 +1433,7 @@ var init_client = __esm({
           `${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)
           }
         );
@@ -1218,9 +1450,7 @@ var init_client = __esm({
       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);
@@ -1237,22 +1467,30 @@ var init_client = __esm({
 
 // src/env.ts
 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 };
 }
-var DEFAULT_BASE_URL;
 var init_env = __esm({
   "src/env.ts"() {
     "use strict";
     init_client();
-    DEFAULT_BASE_URL = "https://api.robotrock.io/v1";
+    init_src();
   }
 });