robotrock 0.9.0 → 1.0.0

package/dist/trigger/index.js

@@ -399,13 +399,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()
 });
@@ -513,6 +515,56 @@ 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 createAgentChatBodySchema = z.object({
+  /** Trigger chat agent id (task slug). 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(),
+  /** 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 agentChatTransportBodySchema = z.object({
+  chatId: z.string().min(1),
+  publicAccessToken: z.string().min(1),
+  lastEventId: z.string().optional(),
+  isStreaming: z.boolean().optional()
+});
 
 // src/schemas/index.ts
 var safeUrlSchema2 = z2.string().refine((url) => isPublicHttpUrl(url), {
@@ -535,13 +587,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({
@@ -673,6 +727,149 @@ function toDiscriminatedApprovalResult(actions, task2) {
   };
 }
 
+// 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 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;
+}
+
+// ../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 APP_SIGNUP_URL = `${PRODUCTION_APP_URL}/sign-up`;
+
+// ../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/chats.ts
+function createChatsApi(config) {
+  const headers = () => ({
+    "Content-Type": "application/json",
+    "X-Api-Key": config.apiKey
+  });
+  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
+        );
+      }
+    }
+  };
+}
+
 // src/client.ts
 var DEFAULT_POLL_INTERVAL_MS = 2e3;
 var DEFAULT_TIMEOUT_MS = 24 * 60 * 60 * 1e3;
@@ -710,14 +907,6 @@ 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;
   baseUrl;
@@ -726,6 +915,10 @@ var RobotRock = class {
   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(
@@ -746,11 +939,19 @@ var RobotRock = class {
     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,
+      apiKey: this.apiKey,
+      app: this.app
+    });
   }
-  /**
-   * Create a task via POST /v1 without waiting for a human response.
-   */
-  async createTask(task2) {
+  async createTaskRequest(task2) {
     const normalizedTask = normalizeSendToHumanInput(task2, {
       webhook: this.webhook,
       app: this.app,
@@ -803,7 +1004,7 @@ var RobotRock = class {
       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
     );
@@ -820,7 +1021,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",
@@ -842,10 +1043,35 @@ 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(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: {
@@ -865,11 +1091,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);
     }
@@ -902,7 +1128,7 @@ var RobotRock = class {
     }
     return data.update;
   }
-  async cancelTask(taskId) {
+  async cancelTaskRequest(taskId) {
     const response = await fetch(`${this.baseUrl}/tasks/${taskId}/cancel`, {
       method: "POST",
       headers: {
@@ -961,38 +1187,6 @@ 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;
-}
 
 // src/env.ts
 var DEFAULT_BASE_URL = "https://api.robotrock.io/v1";