robotrock 0.9.0 → 1.0.0

package/dist/{client-Cy7YLxms.d.ts → client-CzVmjXpz.d.ts}

@@ -1,4 +1,55 @@
-import { TaskContextFormatVersion, TaskContextInput, AssignToInput, TaskPriority, ThreadUpdateStatus, TaskResponse, DiscriminatedApprovalResult, Task, ThreadUpdate } from './schemas/index.js';
+import { TaskContextInput, AssignToInput as AssignToInput$1, TaskPriority, ThreadUpdateStatus, TaskResponse, Task, ThreadUpdate, TaskContextFormatVersion, DiscriminatedApprovalResult } from './schemas/index.js';
+import { AssignToInput, AgentChatSeedMessage } from '@robotrock/core';
+
+/** A chat created via {@link ChatsApi.create}. */
+type CreatedChat = {
+    chatId: string;
+    sessionId: string;
+    userId?: string;
+    agentIdentifier: string;
+    deepLink: string;
+};
+type CreateChatResult = {
+    tenantSlug: string;
+    chats: CreatedChat[];
+};
+type CreateChatInput = {
+    /** Agent to run the chat. Required unless `parentChatId` is provided. */
+    agentIdentifier?: string;
+    /** Spawn a chat from an existing chat; inherits its agent/app/owner and links audit. */
+    parentChatId?: string;
+    /** Trigger connection id to run the chat under (defaults to the tenant's). */
+    connectionId?: string;
+    /** Inbox app bucket. Overrides the client `app` when set. */
+    app?: string;
+    /** Assign to tenant users (email) and/or groups (slug). Narrows inbox visibility. */
+    assignTo?: AssignToInput;
+    /** Chat title shown in the inbox. */
+    title: string;
+    /** Seed messages to preload the conversation. Defaults to a welcome message. */
+    messages?: AgentChatSeedMessage[];
+    /** How the chat was created (statistics/audit). @default "api" */
+    source?: string;
+};
+type CloseChatOptions = {
+    /** Optional human-readable reason recorded on the audit trail. */
+    reason?: string;
+};
+interface ChatsApi {
+    /** Create one or more agent chats and assign them (task-style). */
+    create(input: CreateChatInput): Promise<CreateChatResult>;
+    /** Close (archive) a chat by its public chatId — e.g. when an agent is done. */
+    close(chatId: string, options?: CloseChatOptions): Promise<void>;
+}
+/**
+ * Build the `client.chats` namespace. Mirrors the `client.tasks` surface for the
+ * long-lived chat resource, so a single client creates both tasks and chats.
+ */
+declare function createChatsApi(config: {
+    baseUrl: string;
+    apiKey: string;
+    app?: string;
+}): ChatsApi;
 
 type RobotRockWebhookConfig = {
     url: string;
@@ -60,7 +111,7 @@ type SendToHumanInput<A extends readonly SendToHumanActionInput[] = readonly Sen
     /** Optional idempotency key to prevent duplicate tasks */
     idempotencyKey?: string;
     /** Assign to tenant users (email) and/or groups (slug). Narrows inbox visibility. */
-    assignTo?: AssignToInput;
+    assignTo?: AssignToInput$1;
     /**
      * Groups related tasks together in the inbox. Omit to let the server generate
      * one (returned as `task.threadId`) and reuse it on later tasks in the thread.
@@ -106,13 +157,22 @@ type SendToHumanResult<A extends readonly SendToHumanActionInput[] = readonly Se
     mode: "handled";
     task: TaskResponse["task"];
 } & DiscriminatedApprovalResult<A>);
-declare class RobotRockError extends Error {
-    readonly statusCode: number;
-    readonly response?: unknown | undefined;
-    constructor(message: string, statusCode: number, response?: unknown | undefined);
+
+/** Task CRUD surface, exposed as `client.tasks`. */
+interface TasksApi {
+    /** Create a task via POST /v1 without waiting for a human response. */
+    create<const A extends readonly SendToHumanActionInput[]>(task: SendToHumanWithAppInput<A>): Promise<TaskResponse["task"]>;
+    /** Get a task by public task id. */
+    get(taskId: string): Promise<Task | null>;
+    /** Cancel a task by public task id. */
+    cancel(taskId: string): Promise<void>;
+    /** Log a status update against a thread. */
+    sendUpdate(input: SendUpdateInput): Promise<ThreadUpdate>;
 }
 /**
- * RobotRock API client for creating and querying human-in-the-loop tasks.
+ * RobotRock API client for creating and querying human-in-the-loop tasks and
+ * chats. CRUD lives under `client.tasks` and `client.chats`; the headline
+ * `sendToHuman` verb stays top-level.
  */
 declare class RobotRock {
     private readonly apiKey;
@@ -122,24 +182,38 @@ declare class RobotRock {
     private readonly contextVersion;
     private readonly webhook?;
     private readonly polling;
+    /** Task CRUD: `create`, `get`, `cancel`, `sendUpdate`. */
+    readonly tasks: TasksApi;
+    /** Chat CRUD: `create`, `close`. */
+    readonly chats: ChatsApi;
     constructor(config: RobotRockConfig);
+    private createTaskRequest;
+    sendToHuman<const A extends readonly SendToHumanActionInput[]>(task: SendToHumanWithAppInput<A>): Promise<SendToHumanResult<A>>;
     /**
      * Create a task via POST /v1 without waiting for a human response.
+     * @deprecated Use `client.tasks.create()` instead.
      */
     createTask<const A extends readonly SendToHumanActionInput[]>(task: SendToHumanWithAppInput<A>): Promise<TaskResponse["task"]>;
-    sendToHuman<const A extends readonly SendToHumanActionInput[]>(task: SendToHumanWithAppInput<A>): Promise<SendToHumanResult<A>>;
     /**
      * Get a task by public task id (returned as `task.taskId` from {@link sendToHuman}).
+     * @deprecated Use `client.tasks.get()` instead.
      */
     getTask(taskId: string): Promise<Task | null>;
     /**
-     * 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.
+     * Log a status update against a thread.
+     * @deprecated Use `client.tasks.sendUpdate()` instead.
+     */
+    sendUpdate(input: SendUpdateInput): Promise<ThreadUpdate>;
+    /**
+     * Cancel a task by public task id.
+     * @deprecated Use `client.tasks.cancel()` instead.
      */
-    sendUpdate({ threadId, message, status }: SendUpdateInput): Promise<ThreadUpdate>;
     cancelTask(taskId: string): Promise<void>;
+    private getTaskById;
+    private sendThreadUpdate;
+    private cancelTaskRequest;
 }
 declare function createClient(config: RobotRockConfig): RobotRock;
 declare function attachWebhookToActions(actions: readonly SendToHumanActionInput[], webhook: RobotRockWebhookConfig): TaskContextInput["actions"];
 
-export { RobotRock as R, type SendToHumanActionInput as S, type SendToHumanInput as a, type RobotRockConfig as b, type RobotRockAdvancedConfig as c, RobotRockError as d, type RobotRockPollingClientConfig as e, type RobotRockPollingOptions as f, type RobotRockWebhookClientConfig as g, type RobotRockWebhookConfig as h, type SendToHumanResult as i, type SendToHumanValidUntil as j, type SendUpdateInput as k, attachWebhookToActions as l, createClient as m };
+export { type ChatsApi as C, RobotRock as R, type SendToHumanActionInput as S, type TasksApi as T, type SendToHumanInput as a, type RobotRockConfig as b, type CloseChatOptions as c, type CreateChatInput as d, type CreateChatResult as e, type CreatedChat as f, type RobotRockAdvancedConfig as g, type RobotRockPollingClientConfig as h, type RobotRockPollingOptions as i, type RobotRockWebhookClientConfig as j, type RobotRockWebhookConfig as k, type SendToHumanResult as l, type SendToHumanValidUntil as m, type SendUpdateInput as n, attachWebhookToActions as o, createChatsApi as p, createClient as q };

package/dist/index.d.ts

@@ -1,11 +1,18 @@
-import { R as RobotRock, b as RobotRockConfig } from './client-Cy7YLxms.js';
-export { c as RobotRockAdvancedConfig, d as RobotRockError, e as RobotRockPollingClientConfig, f as RobotRockPollingOptions, g as RobotRockWebhookClientConfig, h as RobotRockWebhookConfig, S as SendToHumanActionInput, a as SendToHumanInput, i as SendToHumanResult, j as SendToHumanValidUntil, k as SendUpdateInput, l as attachWebhookToActions, m as createClient } from './client-Cy7YLxms.js';
+import { R as RobotRock, b as RobotRockConfig } from './client-CzVmjXpz.js';
+export { C as ChatsApi, c as CloseChatOptions, d as CreateChatInput, e as CreateChatResult, f as CreatedChat, g as RobotRockAdvancedConfig, h as RobotRockPollingClientConfig, i as RobotRockPollingOptions, j as RobotRockWebhookClientConfig, k as RobotRockWebhookConfig, S as SendToHumanActionInput, a as SendToHumanInput, l as SendToHumanResult, m as SendToHumanValidUntil, n as SendUpdateInput, T as TasksApi, o as attachWebhookToActions, p as createChatsApi, q as createClient } from './client-CzVmjXpz.js';
+export { AgentChatSeedMessage, CreateAgentChatBody, CreateAgentChatBodyInput, agentChatSeedMessageSchema, createAgentChatBodySchema } from '@robotrock/core';
 import { Task, DiscriminatedApprovalResult } from './schemas/index.js';
 export { AgentTelemetry, AgentTelemetryInput, ApprovalResult, AssignToInput, CreateTaskBody, CreateTaskBodyInput, DEFAULT_TASK_PRIORITY, DEFAULT_THREAD_UPDATE_STATUS, Handler, InferActionData, LOWEST_TASK_PRIORITY, TASK_CONTEXT_FORMAT_VERSION, TASK_PRIORITY_RANK, TaskAction, TaskContext, TaskContextFormatVersion, TaskContextInput, TaskPriority, TaskResponse, TaskResult, TaskStatus, ThreadUpdate, ThreadUpdateBody, ThreadUpdateBodyInput, ThreadUpdateInput, ThreadUpdateResponse, ThreadUpdateSource, ThreadUpdateStatus, TriggerHandler, TupleElementIndices, WebhookHandler, agentTelemetrySchema, assignToSchema, createTaskBodySchema, taskContextSchema, taskPriorities, taskPrioritySchema, threadUpdateBodySchema, threadUpdateInputSchema, threadUpdateStatusSchema, threadUpdateStatuses } from './schemas/index.js';
 import { z } from 'zod';
 export { E as EndRobotRockHumanWaitSpanOptions, b as RobotRockCreatedTask, c as RobotRockHandledOtelInput, a as RobotRockHandlerWebhookPayload, d as RobotRockHumanWaitOtelSession, e as RobotRockOtelHandle, f as RobotRockOtelRecordOptions, R as RobotRockPlatformOtelFields, g as beginRobotRockHumanWaitOtel, h as captureRobotRockOtelHandle, i as endRobotRockHumanWaitSpan, j as finishRobotRockHumanWaitOtel, r as recordRobotRockHandledToOtel, s as shouldRecordRobotRockOtel, k as startRobotRockHumanWaitSpan, l as stripPlatformOtelFields, t as toRobotRockHandledOtelInput } from './otel-platform-DzHyHkGk.js';
 import '@opentelemetry/api';
 
+declare class RobotRockError extends Error {
+    readonly statusCode: number;
+    readonly response?: unknown | undefined;
+    constructor(message: string, statusCode: number, response?: unknown | undefined);
+}
+
 /**
  * Read RobotRock client config from environment variables.
  *
@@ -138,4 +145,4 @@ interface VerifyRobotRockWebhookOptions {
  */
 declare function verifyRobotRockWebhook(request: Request, options?: VerifyRobotRockWebhookOptions): Promise<RobotRockWebhookPayload>;
 
-export { DiscriminatedApprovalResult, type HandledActionInput, type HandledOutcome, PLATFORM_MARK_DONE_ACTION_ID, PLATFORM_MARK_DONE_ACTION_TITLE, PLATFORM_REJECT_REQUEST_ACTION_ID, PLATFORM_REJECT_REQUEST_ACTION_TITLE, PLATFORM_TERMINAL_ACTION_IDS, type PlatformMarkDoneOutcome, type PlatformRejectRequestData, PlatformRejectRequestError, type PlatformRejectRequestOutcome, type PlatformTerminalActionId, RobotRock, RobotRockConfig, RobotRockWebhookError, type RobotRockWebhookErrorCode, type RobotRockWebhookPayload, Task, type TaskActionOutcome, TaskExpiredError, TaskTimeoutError, type VerifyRobotRockWebhookOptions, assertNotPlatformRejectRequest, isPlatformMarkDoneAction, isPlatformRejectRequestAction, isPlatformTerminalAction, parseHandledOutcome, parsePlatformRejectRequestData, resolveRobotRockClient, resolveRobotRockConfig, shouldStopAgentForHandledAction, toDiscriminatedApprovalResult, verifyRobotRockWebhook };
+export { DiscriminatedApprovalResult, type HandledActionInput, type HandledOutcome, PLATFORM_MARK_DONE_ACTION_ID, PLATFORM_MARK_DONE_ACTION_TITLE, PLATFORM_REJECT_REQUEST_ACTION_ID, PLATFORM_REJECT_REQUEST_ACTION_TITLE, PLATFORM_TERMINAL_ACTION_IDS, type PlatformMarkDoneOutcome, type PlatformRejectRequestData, PlatformRejectRequestError, type PlatformRejectRequestOutcome, type PlatformTerminalActionId, RobotRock, RobotRockConfig, RobotRockError, RobotRockWebhookError, type RobotRockWebhookErrorCode, type RobotRockWebhookPayload, Task, type TaskActionOutcome, TaskExpiredError, TaskTimeoutError, type VerifyRobotRockWebhookOptions, assertNotPlatformRejectRequest, isPlatformMarkDoneAction, isPlatformRejectRequestAction, isPlatformTerminalAction, parseHandledOutcome, parsePlatformRejectRequestData, resolveRobotRockClient, resolveRobotRockConfig, shouldStopAgentForHandledAction, toDiscriminatedApprovalResult, verifyRobotRockWebhook };

package/dist/index.js

@@ -202,13 +202,15 @@ var triggerHandlerSchema = webhookHandlerSchema.extend({
   tokenId: z.string().min(1)
 });
 var handlerSchema = z.discriminatedUnion("type", [webhookHandlerSchema, triggerHandlerSchema]);
-var taskActionSchema = z.object({
+var taskActionInputSchema = z.object({
   id: z.string().min(1),
   title: z.string().min(1),
   description: z.string().optional(),
   schema: jsonSchema7Schema.optional(),
   ui: uiSchemaSchema.optional(),
-  data: z.record(z.string(), z.unknown()).optional(),
+  data: z.record(z.string(), z.unknown()).optional()
+});
+var taskActionSchema = taskActionInputSchema.extend({
   // Optional handlers for this action - if present, must have at least 1
   handlers: z.array(handlerSchema).min(1).optional()
 });
@@ -316,6 +318,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), {
@@ -338,13 +390,15 @@ var triggerHandlerSchema2 = webhookHandlerSchema2.extend({
   tokenId: z2.string().min(1)
 });
 var handlerSchema2 = z2.discriminatedUnion("type", [webhookHandlerSchema2, triggerHandlerSchema2]);
-var taskActionSchema2 = z2.object({
+var taskActionInputSchema2 = z2.object({
   id: z2.string().min(1),
   title: z2.string().min(1),
   description: z2.string().optional(),
   schema: jsonSchema7Schema2.optional(),
   ui: uiSchemaSchema2.optional(),
-  data: z2.record(z2.string(), z2.unknown()).optional(),
+  data: z2.record(z2.string(), z2.unknown()).optional()
+});
+var taskActionSchema2 = taskActionInputSchema2.extend({
   handlers: z2.array(handlerSchema2).min(1).optional()
 });
 var uiFieldSchemaSchema2 = z2.object({
@@ -485,6 +539,149 @@ function toDiscriminatedApprovalResult(actions, task) {
   };
 }
 
+// src/http.ts
+var RobotRockError = class extends Error {
+  constructor(message, statusCode, response) {
+    super(message);
+    this.statusCode = statusCode;
+    this.response = response;
+    this.name = "RobotRockError";
+  }
+};
+async function parseResponseBody(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  const bodyText = await response.text();
+  if (!bodyText) {
+    return null;
+  }
+  if (contentType.toLowerCase().includes("application/json")) {
+    try {
+      return JSON.parse(bodyText);
+    } catch {
+    }
+  }
+  try {
+    return JSON.parse(bodyText);
+  } catch {
+    return bodyText;
+  }
+}
+function getErrorMessage(data, fallback) {
+  if (data && typeof data === "object" && !Array.isArray(data)) {
+    const 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;
@@ -522,14 +719,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;
@@ -538,6 +727,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(
@@ -558,11 +751,19 @@ var RobotRock = class {
     this.contextVersion = config.advanced?.contextVersion ?? TASK_CONTEXT_FORMAT_VERSION2;
     this.webhook = config.webhook;
     this.polling = config.polling ?? {};
+    this.tasks = {
+      create: (task) => this.createTaskRequest(task),
+      get: (taskId) => this.getTaskById(taskId),
+      cancel: (taskId) => this.cancelTaskRequest(taskId),
+      sendUpdate: (input) => this.sendThreadUpdate(input)
+    };
+    this.chats = createChatsApi({
+      baseUrl: this.baseUrl,
+      apiKey: this.apiKey,
+      app: this.app
+    });
   }
-  /**
-   * Create a task via POST /v1 without waiting for a human response.
-   */
-  async createTask(task) {
+  async createTaskRequest(task) {
     const normalizedTask = normalizeSendToHumanInput(task, {
       webhook: this.webhook,
       app: this.app,
@@ -615,7 +816,7 @@ var RobotRock = class {
       contextVersion: this.contextVersion,
       agentVersion: this.agentVersion
     });
-    const createdTaskTask = await this.createTask(task);
+    const createdTaskTask = await this.createTaskRequest(task);
     const hasHandlers = normalizedTask.actions.some(
       (action) => Array.isArray(action.handlers) && action.handlers.length > 0
     );
@@ -632,7 +833,7 @@ var RobotRock = class {
     const deadline = validUntilMs !== void 0 ? Math.min(pollingDeadline, validUntilMs) : pollingDeadline;
     const taskId = createdTaskTask.taskId;
     while (Date.now() < deadline) {
-      const existing = await this.getTask(taskId);
+      const existing = await this.getTaskById(taskId);
       if (existing?.status === "handled" && existing.handled) {
         return {
           mode: "handled",
@@ -654,10 +855,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(task) {
+    return this.tasks.create(task);
+  }
   /**
    * Get a task by public task id (returned as `task.taskId` from {@link sendToHuman}).
+   * @deprecated Use `client.tasks.get()` instead.
    */
   async getTask(taskId) {
+    return this.tasks.get(taskId);
+  }
+  /**
+   * Log a status update against a thread.
+   * @deprecated Use `client.tasks.sendUpdate()` instead.
+   */
+  async sendUpdate(input) {
+    return this.tasks.sendUpdate(input);
+  }
+  /**
+   * Cancel a task by public task id.
+   * @deprecated Use `client.tasks.cancel()` instead.
+   */
+  async cancelTask(taskId) {
+    return this.tasks.cancel(taskId);
+  }
+  async getTaskById(taskId) {
     const response = await fetch(`${this.baseUrl}/tasks/${taskId}`, {
       method: "GET",
       headers: {
@@ -677,11 +903,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);
     }
@@ -714,7 +940,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: {
@@ -773,38 +999,6 @@ function normalizeSendToHumanInput(task, clientDefaults) {
     actions: normalizedActions
   };
 }
-async function parseResponseBody(response) {
-  const contentType = response.headers.get("content-type") ?? "";
-  const bodyText = await response.text();
-  if (!bodyText) {
-    return null;
-  }
-  if (contentType.toLowerCase().includes("application/json")) {
-    try {
-      return JSON.parse(bodyText);
-    } catch {
-    }
-  }
-  try {
-    return JSON.parse(bodyText);
-  } catch {
-    return bodyText;
-  }
-}
-function getErrorMessage(data, fallback) {
-  if (data && typeof data === "object" && !Array.isArray(data)) {
-    const maybeMessage = data.message;
-    if (typeof maybeMessage === "string" && maybeMessage.trim()) {
-      return maybeMessage;
-    }
-  }
-  if (typeof data === "string" && data.trim()) {
-    const compact = data.replace(/\s+/g, " ").trim();
-    const snippet = compact.length > 180 ? `${compact.slice(0, 180)}...` : compact;
-    return `${fallback}. Server returned non-JSON response: ${snippet}`;
-  }
-  return fallback;
-}
 
 // src/env.ts
 var DEFAULT_BASE_URL = "https://api.robotrock.io/v1";
@@ -919,18 +1113,18 @@ function shouldStopAgentForHandledAction(actionId) {
 
 // src/webhook.ts
 import { createHmac, timingSafeEqual } from "crypto";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var ROBOTROCK_SIGNATURE_HEADER = "x-robotrock-signature";
-var robotRockWebhookPayloadBodySchema = z3.object({
-  taskId: z3.string().min(1),
-  action: z3.object({
-    id: z3.string().min(1),
-    title: z3.string().min(1),
-    data: z3.unknown()
+var robotRockWebhookPayloadBodySchema = z4.object({
+  taskId: z4.string().min(1),
+  action: z4.object({
+    id: z4.string().min(1),
+    title: z4.string().min(1),
+    data: z4.unknown()
   }),
-  handledBy: z3.string().min(1).optional(),
-  handledAt: z3.string().min(1),
-  handlerType: z3.string().min(1)
+  handledBy: z4.string().min(1).optional(),
+  handledAt: z4.string().min(1),
+  handlerType: z4.string().min(1)
 });
 var RobotRockWebhookError = class extends Error {
   constructor(message, code, details) {
@@ -1230,12 +1424,15 @@ export {
   TASK_PRIORITY_RANK,
   TaskExpiredError,
   TaskTimeoutError,
+  agentChatSeedMessageSchema,
   agentTelemetrySchema2 as agentTelemetrySchema,
   assertNotPlatformRejectRequest,
   assignToSchema2 as assignToSchema,
   attachWebhookToActions,
   beginRobotRockHumanWaitOtel,
   captureRobotRockOtelHandle,
+  createAgentChatBodySchema,
+  createChatsApi,
   createClient,
   createTaskBodySchema2 as createTaskBodySchema,
   endRobotRockHumanWaitSpan,