robotrock 0.9.0 → 1.1.0

package/dist/ai/workflow.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, taskActionSchema, uiFieldSchemaSchema, contextUiSchema, contextDataSchema, TASK_CONTEXT_FORMAT_VERSION, taskContextObjectBaseSchema, taskContextObjectSchema, taskContextSchema, assignToSchema, threadUpdateMessageSchema, threadUpdateStatuses, threadUpdateStatusSchema, threadUpdateInputSchema, taskPriorities, taskPrioritySchema, agentTelemetrySchema, createTaskBodySchema;
+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({
@@ -327,13 +358,15 @@ var init_task = __esm({
       tokenId: z.string().min(1)
     });
     handlerSchema = z.discriminatedUnion("type", [webhookHandlerSchema, triggerHandlerSchema]);
-    taskActionSchema = z.object({
+    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()
+    });
+    taskActionSchema = taskActionInputSchema.extend({
       // Optional handlers for this action - if present, must have at least 1
       handlers: z.array(handlerSchema).min(1).optional()
     });
@@ -424,6 +457,96 @@ var init_task = __esm({
       /** Agent release version — not shown in inbox UI. */
       agent: agentTelemetrySchema.optional()
     }).transform(normalizeTaskContextVersion).superRefine(refineContextPublicUrls);
+    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()
+    });
+    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()
+    });
+    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({
+      /** 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"
+    });
+    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)
+    });
   }
 });
 
@@ -463,14 +586,14 @@ function refineContextPublicUrls2(data, ctx) {
     });
   }
 }
-var safeUrlSchema2, jsonSchema7Schema2, uiSchemaSchema2, webhookHandlerSchema2, triggerHandlerSchema2, handlerSchema2, 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,
@@ -481,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({
@@ -489,13 +612,15 @@ var init_schemas2 = __esm({
       tokenId: z2.string().min(1)
     });
     handlerSchema2 = z2.discriminatedUnion("type", [webhookHandlerSchema2, triggerHandlerSchema2]);
-    taskActionSchema2 = z2.object({
+    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()
+    });
+    taskActionSchema2 = taskActionInputSchema2.extend({
       handlers: z2.array(handlerSchema2).min(1).optional()
     });
     uiFieldSchemaSchema2 = z2.object({
@@ -618,6 +743,398 @@ var init_approval_result = __esm({
   }
 });
 
+// src/http.ts
+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;
+}
+var RobotRockError;
+var init_http = __esm({
+  "src/http.ts"() {
+    "use strict";
+    RobotRockError = class extends Error {
+      constructor(message, statusCode, response) {
+        super(message);
+        this.statusCode = statusCode;
+        this.response = response;
+        this.name = "RobotRockError";
+      }
+    };
+  }
+});
+
+// ../core/src/types/task.ts
+var init_task2 = __esm({
+  "../core/src/types/task.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/types/json-schema-infer.ts
+var init_json_schema_infer = __esm({
+  "../core/src/types/json-schema-infer.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/types/index.ts
+var init_types = __esm({
+  "../core/src/types/index.ts"() {
+    "use strict";
+    init_task2();
+    init_json_schema_infer();
+  }
+});
+
+// ../core/src/plans/index.ts
+var init_plans = __esm({
+  "../core/src/plans/index.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/handler-retry.ts
+var HANDLER_RETRY_DELAYS_MS, HANDLER_MAX_ATTEMPTS;
+var init_handler_retry = __esm({
+  "../core/src/handler-retry.ts"() {
+    "use strict";
+    HANDLER_RETRY_DELAYS_MS = [
+      6e4,
+      // 1m
+      3e5,
+      // 5m
+      18e5,
+      // 30m
+      36e5,
+      // 1h
+      216e5,
+      // 6h
+      864e5,
+      // 24h
+      1728e5
+      // 48h
+    ];
+    HANDLER_MAX_ATTEMPTS = HANDLER_RETRY_DELAYS_MS.length + 1;
+  }
+});
+
+// ../core/src/legal.ts
+var init_legal = __esm({
+  "../core/src/legal.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/welcome-task.ts
+var init_welcome_task = __esm({
+  "../core/src/welcome-task.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/app-url.ts
+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`;
+  }
+});
+
+// ../core/src/attribution/index.ts
+import { z as z3 } from "zod";
+var ATTRIBUTION_COOKIE_MAX_AGE, attributionSchema;
+var init_attribution = __esm({
+  "../core/src/attribution/index.ts"() {
+    "use strict";
+    init_app_url();
+    init_app_url();
+    ATTRIBUTION_COOKIE_MAX_AGE = 60 * 60 * 24 * 90;
+    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()
+    });
+  }
+});
+
+// ../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"() {
+    "use strict";
+    init_schemas();
+    init_types();
+    init_utils();
+    init_plans();
+    init_handler_retry();
+    init_legal();
+    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";
+  }
+});
+
+// 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
+        );
+      }
+    }
+  };
+}
+var init_chats = __esm({
+  "src/chats.ts"() {
+    "use strict";
+    init_src();
+    init_http();
+    init_auth_headers();
+  }
+});
+
 // src/client.ts
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -695,62 +1212,31 @@ function normalizeSendToHumanInput(task2, 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;
-}
-var DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS, RobotRockError, RobotRock;
+var DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS, RobotRock;
 var init_client = __esm({
   "src/client.ts"() {
     "use strict";
     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;
-    RobotRockError = class extends Error {
-      constructor(message, statusCode, response) {
-        super(message);
-        this.statusCode = statusCode;
-        this.response = response;
-        this.name = "RobotRockError";
-      }
-    };
     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(
@@ -758,24 +1244,42 @@ 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;
         this.webhook = config.webhook;
         this.polling = config.polling ?? {};
+        this.tasks = {
+          create: (task2) => this.createTaskRequest(task2),
+          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(task2) {
+      authHeaders(extra) {
+        return {
+          "Content-Type": "application/json",
+          ...buildRobotRockAuthHeaders(this.auth),
+          ...extra
+        };
+      }
+      async createTaskRequest(task2) {
         const normalizedTask = normalizeSendToHumanInput(task2, {
           webhook: this.webhook,
           app: this.app,
@@ -799,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,
@@ -828,7 +1328,7 @@ var init_client = __esm({
           contextVersion: this.contextVersion,
           agentVersion: this.agentVersion
         });
-        const createdTaskTask = await this.createTask(task2);
+        const createdTaskTask = await this.createTaskRequest(task2);
         const hasHandlers = normalizedTask.actions.some(
           (action) => Array.isArray(action.handlers) && action.handlers.length > 0
         );
@@ -845,7 +1345,7 @@ var init_client = __esm({
         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",
@@ -867,15 +1367,38 @@ var init_client = __esm({
         }
         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(task2) {
+        return this.tasks.create(task2);
+      }
       /**
        * 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;
@@ -890,11 +1413,11 @@ var init_client = __esm({
         }
         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);
         }
@@ -910,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)
           }
         );
@@ -927,12 +1447,10 @@ var init_client = __esm({
         }
         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);
@@ -949,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();
   }
 });
 
@@ -1470,7 +1996,7 @@ async function sendRobotRockUpdate(payload) {
     ...baseConfig.version ? { version: baseConfig.version } : {},
     ...baseConfig.advanced ? { advanced: baseConfig.advanced } : {}
   });
-  return client.sendUpdate(update);
+  return client.tasks.sendUpdate(update);
 }
 async function sendUpdateInWorkflow(payload) {
   return sendRobotRockUpdate(payload);
@@ -1493,7 +2019,7 @@ var init_workflow = __esm({
 });
 
 // src/ai/approve-by-human-tool-core.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/ai/context.ts
 init_client();
@@ -1569,9 +2095,9 @@ async function sendUpdateForAi(context2, payload) {
     const client = createClient(
       resolveRobotRockConfig(context2.app ? { app: context2.app } : void 0)
     );
-    return client.sendUpdate(payload);
+    return client.tasks.sendUpdate(payload);
   }
-  return context2.client.sendUpdate(payload);
+  return context2.client.tasks.sendUpdate(payload);
 }
 async function approveByHumanForAi(context2, payload) {
   if (context2.mode === "trigger") {
@@ -1630,11 +2156,11 @@ function toHumanToolResult(result) {
 }
 
 // src/ai/approve-by-human-tool-core.ts
-var approveByHumanInputSchema = z3.object({
-  type: z3.string().optional().describe("Task type slug; defaults to ai-approval"),
-  name: z3.string().describe("Short title for the approval request"),
-  description: z3.string().describe("What needs approval and the consequences of approving or declining"),
-  contextSummary: z3.string().optional().describe("Optional markdown summary shown to the reviewer")
+var approveByHumanInputSchema = z4.object({
+  type: z4.string().optional().describe("Task type slug; defaults to ai-approval"),
+  name: z4.string().describe("Short title for the approval request"),
+  description: z4.string().describe("What needs approval and the consequences of approving or declining"),
+  contextSummary: z4.string().optional().describe("Optional markdown summary shown to the reviewer")
 });
 function resolveApproveByHumanToolConfig(clientOrContext, maybeOptions = {}) {
   const isDurable = typeof clientOrContext === "object" && clientOrContext !== null && "mode" in clientOrContext && (clientOrContext.mode === "trigger" || clientOrContext.mode === "workflow");
@@ -1676,16 +2202,16 @@ function buildApproveByHumanToolDefinition(clientOrContext, maybeOptions = {}) {
 
 // src/ai/create-send-to-human-tool-core.ts
 init_schemas2();
-import { z as z4 } from "zod";
-var sendToHumanToolInputSchema = z4.object({
-  type: z4.string().describe("Task type slug shown in the RobotRock inbox"),
-  name: z4.string().describe("Short title for the human reviewer"),
-  description: z4.string().optional().describe("What you need from the human and why you cannot proceed alone"),
-  context: z4.object({
-    data: z4.record(z4.string(), z4.unknown()).optional(),
-    ui: z4.record(z4.string(), z4.unknown()).optional()
+import { z as z5 } from "zod";
+var sendToHumanToolInputSchema = z5.object({
+  type: z5.string().describe("Task type slug shown in the RobotRock inbox"),
+  name: z5.string().describe("Short title for the human reviewer"),
+  description: z5.string().optional().describe("What you need from the human and why you cannot proceed alone"),
+  context: z5.object({
+    data: z5.record(z5.string(), z5.unknown()).optional(),
+    ui: z5.record(z5.string(), z5.unknown()).optional()
   }).optional().describe("Optional structured context for the inbox UI"),
-  validUntil: z4.string().datetime().optional().describe("Optional ISO deadline for the task"),
+  validUntil: z5.string().datetime().optional().describe("Optional ISO deadline for the task"),
   assignTo: assignToSchema2.optional().describe(
     "Assign to tenant member emails and/or group slugs; narrows who sees the task in the inbox"
   )
@@ -1731,12 +2257,12 @@ function buildSendToHumanToolDefinition(clientOrOptions, maybeOptions) {
 // src/ai/create-send-update-tool-core.ts
 init_schemas2();
 init_client();
-import { z as z5 } from "zod";
-var sendUpdateToolInputSchema = z5.object({
-  threadId: z5.string().optional().describe(
+import { z as z6 } from "zod";
+var sendUpdateToolInputSchema = z6.object({
+  threadId: z6.string().optional().describe(
     "Thread to post the update to. Use the `threadId` returned by a prior send-to-human task. Omit only when a session threadId is configured on the tool."
   ),
-  message: z5.string().describe("Short progress update (1-2 sentences) shown in the inbox status bar"),
+  message: z6.string().describe("Short progress update (1-2 sentences) shown in the inbox status bar"),
   status: threadUpdateStatusSchema2.optional().describe(
     "Lifecycle status driving the status-bar icon/color: info, queued, running, waiting, succeeded, failed, cancelled"
   )
@@ -1787,6 +2313,84 @@ function buildSendUpdateToolDefinition(clientOrOptions, maybeOptions = {}) {
   };
 }
 
+// src/ai/request-action-input-tool-core.ts
+import { z as z7 } from "zod";
+var requestActionInputActionSchema = z7.object({
+  id: z7.string().min(1).optional().describe(
+    "Stable action identifier echoed in tool output (e.g. pick-blog-topic). Strongly recommended \u2014 auto-derived from title when omitted."
+  ),
+  title: z7.string().min(1),
+  description: z7.string().optional(),
+  schema: z7.record(z7.string(), z7.unknown()).optional().describe("JSON Schema object for the human feedback form"),
+  ui: z7.record(z7.string(), z7.unknown()).optional().describe(
+    'RJSF ui schema overrides (ui:widget, ui:enumNames, etc.). Use ui:widget "radio" for 2\u20136 discrete choices rendered as tappable cards.'
+  ),
+  data: z7.record(z7.string(), z7.unknown()).optional().describe("Optional default form field values")
+});
+var requestActionInputToolOutputSchema = z7.object({
+  actionId: z7.string().min(1),
+  data: z7.record(z7.string(), z7.unknown())
+});
+var requestActionInputToolInputSchema = z7.object({
+  prompt: z7.string().optional().describe("Optional heading shown above the action widget in chat"),
+  action: requestActionInputActionSchema.describe(
+    "Action widget config: JSON Schema form fields and optional RJSF ui overrides (same shape as RobotRock inbox actions)"
+  )
+});
+function buildRequestActionInputToolDefinition(options = {}) {
+  const description = options.description ?? `Ask the user for structured input via a RobotRock action widget in chat. Always set action.id (e.g. "pick-blog-topic") and action.title. Provide action.schema and optional action.ui using the same JSON Schema and RJSF ui shape as inbox action widgets. Put every field you need in a single call \u2014 never invoke this tool more than once per turn. For 2\u20136 discrete options, use a string enum with ui:widget "radio" and ui:enumNames \u2014 never markdown bullet lists. After the tool returns, act on the user's data immediately; do not ask them to confirm choices they already submitted.`;
+  return {
+    description,
+    inputSchema: requestActionInputToolInputSchema,
+    outputSchema: requestActionInputToolOutputSchema
+  };
+}
+
+// src/ai/report-status-tool-core.ts
+import { z as z8 } from "zod";
+var reportStatusPhaseSchema = z8.enum([
+  "info",
+  "running",
+  "waiting",
+  "succeeded",
+  "failed"
+]);
+var reportStatusToolInputSchema = z8.object({
+  message: z8.string().min(1).describe(
+    "Short progress update shown in chat (1-2 sentences). Use while researching, drafting, or waiting on external work."
+  ),
+  phase: reportStatusPhaseSchema.optional().describe(
+    "Lifecycle phase for the status marker. Defaults to running. Use succeeded or failed when a step finishes."
+  )
+});
+var reportStatusToolOutputSchema = z8.object({
+  message: z8.string().min(1),
+  phase: reportStatusPhaseSchema
+});
+function normalizeReportStatusToolInput(input) {
+  const parsed = reportStatusToolInputSchema.parse(input);
+  return {
+    message: parsed.message.trim(),
+    phase: parsed.phase
+  };
+}
+async function executeReportStatusTool(input) {
+  const normalized = normalizeReportStatusToolInput(input);
+  return {
+    message: normalized.message,
+    phase: normalized.phase ?? "running"
+  };
+}
+function buildReportStatusToolDefinition(options = {}) {
+  const description = options.description ?? 'Post a short progress update to the chat UI while you work. Call this before and during long steps (research, drafting, tool runs) so the user sees what is happening. Use phase "running" while in progress, "succeeded" or "failed" when a step completes, and "waiting" when blocked on external input.';
+  return {
+    description,
+    inputSchema: reportStatusToolInputSchema,
+    outputSchema: reportStatusToolOutputSchema,
+    execute: executeReportStatusTool
+  };
+}
+
 // src/ai/workflow-tools.ts
 function approveByHumanTool(clientOrContext, maybeOptions = {}) {
   return buildApproveByHumanToolDefinition(clientOrContext, maybeOptions);
@@ -1797,6 +2401,12 @@ function createSendToHumanTool(clientOrOptions, maybeOptions) {
 function createSendUpdateTool(clientOrOptions, maybeOptions = {}) {
   return buildSendUpdateToolDefinition(clientOrOptions, maybeOptions);
 }
+function requestActionInputTool(options = {}) {
+  return buildRequestActionInputToolDefinition(options);
+}
+function reportStatusTool(options = {}) {
+  return buildReportStatusToolDefinition(options);
+}
 function createRobotRockAiTools(options = {}) {
   const context2 = { mode: "workflow", app: options.app };
   return {
@@ -1811,7 +2421,9 @@ function createRobotRockAiTools(options = {}) {
       ...context2,
       ...options.threadId ? { threadId: options.threadId } : {},
       ...toolOptions
-    })
+    }),
+    requestActionInput: (toolOptions = {}) => buildRequestActionInputToolDefinition(toolOptions),
+    reportStatus: (toolOptions = {}) => buildReportStatusToolDefinition(toolOptions)
   };
 }
 
@@ -2075,6 +2687,8 @@ export {
   createRobotRockToolApproval,
   createSendToHumanTool,
   createSendUpdateTool,
+  reportStatusTool,
+  requestActionInputTool,
   resolveToolApprovalsViaRobotRock,
   runWithRobotRockApprovals
 };