robotrock 0.8.5 → 1.0.0

package/dist/workflow/index.js

@@ -213,12 +213,12 @@ function validateUrlValue(value, widget) {
   }
   return null;
 }
-function validateContextPublicUrls(context) {
-  if (!context?.data) {
+function validateContextPublicUrls(context2) {
+  if (!context2?.data) {
     return null;
   }
-  for (const [field, value] of Object.entries(context.data)) {
-    const widget = widgetType(context.ui, field);
+  for (const [field, value] of Object.entries(context2.data)) {
+    const widget = widgetType(context2.ui, field);
     if (!widget) {
       continue;
     }
@@ -251,13 +251,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()
 });
@@ -273,7 +275,8 @@ var contextDataSchema = z.object({
   data: z.record(z.string(), z.unknown()),
   ui: contextUiSchema
 }).optional();
-var taskContextObjectSchema = z.object({
+var TASK_CONTEXT_FORMAT_VERSION = 2;
+var taskContextObjectBaseSchema = z.object({
   /** Source application id; omitted tasks are grouped in the default inbox. */
   app: z.string().min(1).optional(),
   type: z.string().min(1),
@@ -281,9 +284,22 @@ var taskContextObjectSchema = z.object({
   description: z.string().optional(),
   validUntil: z.string().optional(),
   context: contextDataSchema,
+  /** Task context wire format version. @default 2 */
+  contextVersion: z.literal(2).optional(),
+  /** @deprecated Use `contextVersion`. Accepted on ingest only. */
   version: z.literal(2).optional(),
   actions: z.array(taskActionSchema).min(1, "At least one action is required")
 });
+function normalizeTaskContextVersion(data) {
+  const { version: legacyVersion, contextVersion, ...rest } = data;
+  return {
+    ...rest,
+    contextVersion: contextVersion ?? legacyVersion ?? TASK_CONTEXT_FORMAT_VERSION
+  };
+}
+var taskContextObjectSchema = taskContextObjectBaseSchema.transform(
+  normalizeTaskContextVersion
+);
 function refineContextPublicUrls(data, ctx) {
   const error = validateContextPublicUrls(data.context);
   if (error) {
@@ -327,61 +343,11 @@ var threadUpdateInputSchema = z.object({
 });
 var taskPriorities = ["low", "normal", "high", "urgent"];
 var taskPrioritySchema = z.enum(taskPriorities);
-var nonNegativeInt = z.number().int().nonnegative();
-var agentCostTokensSchema = z.object({
-  input: nonNegativeInt.optional(),
-  output: nonNegativeInt.optional(),
-  total: nonNegativeInt.optional()
-});
-var agentCostSchema = z.object({
-  tokens: agentCostTokensSchema.optional(),
-  eur: z.number().nonnegative().optional(),
-  usd: z.number().nonnegative().optional()
-});
-var AGENT_INFO_MAX_KEYS = 32;
-var AGENT_TOOL_CALLS_MAX_KEYS = 64;
-var AGENT_OTEL_SPANS_MAX = 32;
-var agentToolCallsSchema = z.record(z.string().min(1), nonNegativeInt);
-var agentOtelSpanStatusSchema = z.enum(["ok", "error"]);
-var agentOtelSpanSummarySchema = z.object({
-  name: z.string().min(1),
-  durationMs: z.number().nonnegative(),
-  status: agentOtelSpanStatusSchema
-});
-var agentOtelSchema = z.object({
-  traceId: z.string().min(1),
-  spanId: z.string().min(1).optional(),
-  rootDurationMs: z.number().nonnegative().optional(),
-  spans: z.array(agentOtelSpanSummarySchema).max(AGENT_OTEL_SPANS_MAX).optional()
-});
 var agentTelemetrySchema = z.object({
   /** Agent or app version (semver, git SHA, deploy tag — caller-defined). */
-  version: z.string().min(1).optional(),
-  /** Total tool invocations. When omitted but `toolCalls` is set, the sum of counts is used. */
-  toolCallCount: nonNegativeInt.optional(),
-  /** Per-tool invocation counts keyed by tool name. */
-  toolCalls: agentToolCallsSchema.optional(),
-  cost: agentCostSchema.optional(),
-  /** Free-form metadata for experiments (model, prompt variant, etc.). */
-  info: z.record(z.string(), z.unknown()).optional(),
-  /** Structured OpenTelemetry span snapshot for feedback analysis. */
-  otel: agentOtelSchema.optional()
-}).refine(
-  (data) => {
-    const keys = data.info ? Object.keys(data.info) : [];
-    return keys.length <= AGENT_INFO_MAX_KEYS;
-  },
-  { message: `agent.info may contain at most ${AGENT_INFO_MAX_KEYS} keys` }
-).refine(
-  (data) => {
-    const keys = data.toolCalls ? Object.keys(data.toolCalls) : [];
-    return keys.length <= AGENT_TOOL_CALLS_MAX_KEYS;
-  },
-  {
-    message: `agent.toolCalls may contain at most ${AGENT_TOOL_CALLS_MAX_KEYS} tool names`
-  }
-);
-var createTaskBodySchema = taskContextObjectSchema.extend({
+  version: z.string().min(1)
+});
+var createTaskBodySchema = taskContextObjectBaseSchema.extend({
   assignTo: assignToSchema.optional(),
   /**
    * Groups related tasks together. When omitted, the server generates one and
@@ -398,9 +364,59 @@ var createTaskBodySchema = taskContextObjectSchema.extend({
    * the inbox status bar and the thread update log.
    */
   update: threadUpdateInputSchema.optional(),
-  /** Agent telemetry (version, cost, tool calls) — not shown in inbox UI. */
+  /** Agent release version — not shown in inbox UI. */
   agent: agentTelemetrySchema.optional()
-}).superRefine(refineContextPublicUrls);
+}).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), {
@@ -423,13 +439,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({
@@ -444,16 +462,29 @@ var contextDataSchema2 = z2.object({
   data: z2.record(z2.string(), z2.unknown()),
   ui: contextUiSchema2
 }).optional();
-var taskContextObjectSchema2 = z2.object({
+var TASK_CONTEXT_FORMAT_VERSION2 = 2;
+var taskContextObjectBaseSchema2 = z2.object({
   app: z2.string().min(1).optional(),
   type: z2.string().min(1),
   name: z2.string().min(1),
   description: z2.string().optional(),
   validUntil: z2.string().optional(),
   context: contextDataSchema2,
+  contextVersion: z2.literal(2).optional(),
+  /** @deprecated Use `contextVersion`. Accepted on ingest only. */
   version: z2.literal(2).optional(),
   actions: z2.array(taskActionSchema2).min(1, "At least one action is required")
 });
+function normalizeTaskContextVersion2(data) {
+  const { version: legacyVersion, contextVersion, ...rest } = data;
+  return {
+    ...rest,
+    contextVersion: contextVersion ?? legacyVersion ?? TASK_CONTEXT_FORMAT_VERSION2
+  };
+}
+var taskContextObjectSchema2 = taskContextObjectBaseSchema2.transform(
+  normalizeTaskContextVersion2
+);
 function refineContextPublicUrls2(data, ctx) {
   const error = validateContextPublicUrls(data.context);
   if (error) {
@@ -497,56 +528,10 @@ var threadUpdateInputSchema2 = z2.object({
 });
 var taskPriorities2 = ["low", "normal", "high", "urgent"];
 var taskPrioritySchema2 = z2.enum(taskPriorities2);
-var nonNegativeInt2 = z2.number().int().nonnegative();
-var agentCostTokensSchema2 = z2.object({
-  input: nonNegativeInt2.optional(),
-  output: nonNegativeInt2.optional(),
-  total: nonNegativeInt2.optional()
-});
-var agentCostSchema2 = z2.object({
-  tokens: agentCostTokensSchema2.optional(),
-  eur: z2.number().nonnegative().optional(),
-  usd: z2.number().nonnegative().optional()
-});
-var AGENT_INFO_MAX_KEYS2 = 32;
-var AGENT_TOOL_CALLS_MAX_KEYS2 = 64;
-var AGENT_OTEL_SPANS_MAX2 = 32;
-var agentToolCallsSchema2 = z2.record(z2.string().min(1), nonNegativeInt2);
-var agentOtelSpanStatusSchema2 = z2.enum(["ok", "error"]);
-var agentOtelSpanSummarySchema2 = z2.object({
-  name: z2.string().min(1),
-  durationMs: z2.number().nonnegative(),
-  status: agentOtelSpanStatusSchema2
-});
-var agentOtelSchema2 = z2.object({
-  traceId: z2.string().min(1),
-  spanId: z2.string().min(1).optional(),
-  rootDurationMs: z2.number().nonnegative().optional(),
-  spans: z2.array(agentOtelSpanSummarySchema2).max(AGENT_OTEL_SPANS_MAX2).optional()
-});
 var agentTelemetrySchema2 = z2.object({
-  version: z2.string().min(1).optional(),
-  toolCallCount: nonNegativeInt2.optional(),
-  toolCalls: agentToolCallsSchema2.optional(),
-  cost: agentCostSchema2.optional(),
-  info: z2.record(z2.string(), z2.unknown()).optional(),
-  otel: agentOtelSchema2.optional()
-}).refine(
-  (data) => {
-    const keys = data.info ? Object.keys(data.info) : [];
-    return keys.length <= AGENT_INFO_MAX_KEYS2;
-  },
-  { message: `agent.info may contain at most ${AGENT_INFO_MAX_KEYS2} keys` }
-).refine(
-  (data) => {
-    const keys = data.toolCalls ? Object.keys(data.toolCalls) : [];
-    return keys.length <= AGENT_TOOL_CALLS_MAX_KEYS2;
-  },
-  {
-    message: `agent.toolCalls may contain at most ${AGENT_TOOL_CALLS_MAX_KEYS2} tool names`
-  }
-);
-var createTaskBodySchema2 = taskContextObjectSchema2.extend({
+  version: z2.string().min(1)
+});
+var createTaskBodySchema2 = taskContextObjectBaseSchema2.extend({
   assignTo: assignToSchema2.optional(),
   /**
    * Groups related tasks together. When omitted, the server generates one and
@@ -564,7 +549,7 @@ var createTaskBodySchema2 = taskContextObjectSchema2.extend({
    */
   update: threadUpdateInputSchema2.optional(),
   agent: agentTelemetrySchema2.optional()
-}).superRefine(refineContextPublicUrls2);
+}).transform(normalizeTaskContextVersion2).superRefine(refineContextPublicUrls2);
 var threadUpdateBodySchema = threadUpdateInputSchema2;
 
 // src/approval-result.ts
@@ -594,12 +579,159 @@ 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;
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function resolveAgentVersionFromEnv() {
+  const fromEnv = process.env.AGENT_VERSION?.trim() || process.env.ROBOTROCK_AGENT_VERSION?.trim();
+  return fromEnv || void 0;
+}
 function parseValidUntilMs(value) {
   if (value === void 0) {
     return void 0;
@@ -627,21 +759,18 @@ 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;
   app;
-  version;
+  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(
@@ -658,26 +787,37 @@ var RobotRock = class {
     const rawBase = config.baseUrl ?? "https://api.robotrock.io/v1";
     this.baseUrl = rawBase.replace(/\/+$/, "");
     this.app = config.app;
-    this.version = config.version ?? 2;
+    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: (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,
-      version: this.version
+      contextVersion: this.contextVersion,
+      agentVersion: this.agentVersion
     });
+    const agentVersion = task.version ?? this.agentVersion;
     const bodyPayload = {
       ...normalizedTask,
       ...task.assignTo !== void 0 ? { assignTo: task.assignTo } : {},
       ...task.threadId !== void 0 ? { threadId: task.threadId } : {},
       ...task.priority !== void 0 ? { priority: task.priority } : {},
       ...task.update !== void 0 ? { update: task.update } : {},
-      ...task.agent !== void 0 ? { agent: task.agent } : {}
+      ...agentVersion !== void 0 ? { agent: { version: agentVersion } } : {}
     };
     const validation = createTaskBodySchema2.safeParse(bodyPayload);
     if (!validation.success) {
@@ -713,9 +853,10 @@ var RobotRock = class {
     const normalizedTask = normalizeSendToHumanInput(task, {
       webhook: this.webhook,
       app: this.app,
-      version: this.version
+      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
     );
@@ -732,7 +873,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",
@@ -754,10 +895,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: {
@@ -777,11 +943,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);
     }
@@ -814,7 +980,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: {
@@ -857,6 +1023,7 @@ function normalizeSendToHumanInput(task, clientDefaults) {
     threadId: _threadId,
     priority: _priority,
     update: _update,
+    version: _version,
     validUntil,
     app: taskApp,
     ...rest
@@ -866,44 +1033,12 @@ function normalizeSendToHumanInput(task, clientDefaults) {
   const app = taskApp ?? clientDefaults.app;
   return {
     ...rest,
-    version: clientDefaults.version,
+    contextVersion: clientDefaults.contextVersion,
     ...app ? { app } : {},
     ...validUntil !== void 0 ? { validUntil: serializeValidUntil(validUntil) } : {},
     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";
@@ -980,6 +1115,200 @@ function durationMsToTimeout(durationMs) {
   return `${seconds}s`;
 }
 
+// src/record-handled-to-otel.ts
+import {
+  context,
+  trace,
+  SpanStatusCode
+} from "@opentelemetry/api";
+var TRACER_NAME = "robotrock";
+var WAIT_SPAN_NAME = "robotrock.wait_for_human";
+var HANDLED_EVENT_NAME = "robotrock.task_handled";
+var INVALID_TRACE_ID = "00000000000000000000000000000000";
+function isValidTraceId(traceId) {
+  return typeof traceId === "string" && traceId.length > 0 && traceId !== INVALID_TRACE_ID;
+}
+function resolveSpanContext(span) {
+  const active = span ?? trace.getActiveSpan();
+  const ctx = active?.spanContext();
+  if (!ctx || !isValidTraceId(ctx.traceId)) {
+    return void 0;
+  }
+  return { traceId: ctx.traceId, spanId: ctx.spanId };
+}
+function parseTaskCreatedAt(submittedAt) {
+  if (submittedAt) {
+    const parsed = Date.parse(submittedAt);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return Date.now();
+}
+function parseHandledAtMs(handledAt) {
+  if (handledAt instanceof Date) {
+    return handledAt.getTime();
+  }
+  if (typeof handledAt === "number") {
+    return handledAt;
+  }
+  const parsed = Date.parse(handledAt);
+  return Number.isNaN(parsed) ? Date.now() : parsed;
+}
+function toRobotRockHandledOtelInput(handled) {
+  if ("actionId" in handled) {
+    return {
+      taskId: handled.taskId,
+      action: {
+        id: handled.actionId,
+        data: handled.data
+      },
+      handledBy: handled.handledBy,
+      handledAt: handled.handledAt
+    };
+  }
+  return {
+    taskId: handled.taskId,
+    action: {
+      id: handled.action.id,
+      title: handled.action.title,
+      data: handled.action.data
+    },
+    handledBy: handled.handledBy,
+    handledAt: handled.handledAt
+  };
+}
+function captureRobotRockOtelHandle(task, options) {
+  const spanCtx = resolveSpanContext(options?.span);
+  return {
+    traceId: spanCtx?.traceId ?? "",
+    spanId: spanCtx?.spanId ?? "",
+    taskId: task.taskId,
+    threadId: task.threadId,
+    taskCreatedAt: parseTaskCreatedAt(task.submittedAt)
+  };
+}
+function startRobotRockHumanWaitSpan(handle, options) {
+  const parent = options?.span ?? trace.getActiveSpan();
+  if (!parent) {
+    return void 0;
+  }
+  const tracer = trace.getTracer(options?.tracerName ?? TRACER_NAME);
+  const span = tracer.startSpan(
+    WAIT_SPAN_NAME,
+    {},
+    trace.setSpan(context.active(), parent)
+  );
+  span.setAttribute("robotrock.task_id", handle.taskId);
+  if (handle.threadId) {
+    span.setAttribute("robotrock.thread_id", handle.threadId);
+  }
+  return span;
+}
+function recordRobotRockHandledToOtel(handled, options = {}) {
+  const span = options.span ?? trace.getActiveSpan();
+  if (!span) {
+    return;
+  }
+  const input = toRobotRockHandledOtelInput(handled);
+  const handledAtMs = parseHandledAtMs(input.handledAt);
+  const handle = options.handle;
+  const humanWaitMs = handle != null ? Math.max(0, handledAtMs - handle.taskCreatedAt) : void 0;
+  span.setAttribute("robotrock.task_id", input.taskId);
+  span.setAttribute("robotrock.action.id", input.action.id);
+  if (input.action.title) {
+    span.setAttribute("robotrock.action.title", input.action.title);
+  }
+  if (input.handledBy) {
+    span.setAttribute("robotrock.handled_by", input.handledBy);
+  }
+  span.setAttribute("robotrock.handled_at", new Date(handledAtMs).toISOString());
+  if (humanWaitMs != null) {
+    span.setAttribute("robotrock.human_wait_ms", humanWaitMs);
+  }
+  if (input.threadId) {
+    span.setAttribute("robotrock.thread_id", input.threadId);
+  }
+  const eventAttributes = {
+    "robotrock.task_id": input.taskId,
+    "robotrock.action.id": input.action.id
+  };
+  if (input.handledBy) {
+    eventAttributes["robotrock.handled_by"] = input.handledBy;
+  }
+  if (humanWaitMs != null) {
+    eventAttributes["robotrock.human_wait_ms"] = humanWaitMs;
+  }
+  if (options.includeActionData && input.action.data != null) {
+    const serialized = JSON.stringify(input.action.data);
+    const truncated = serialized.length > 512 ? `${serialized.slice(0, 512)}\u2026` : serialized;
+    span.setAttribute("robotrock.action.data", truncated);
+    eventAttributes["robotrock.action.data"] = truncated;
+  }
+  span.addEvent(HANDLED_EVENT_NAME, eventAttributes);
+}
+function endRobotRockHumanWaitSpan(span, handled, options = {}) {
+  if (!span) {
+    return;
+  }
+  const outcome = options.outcome ?? (handled ? "handled" : "timeout");
+  if (handled && outcome === "handled") {
+    recordRobotRockHandledToOtel(handled, {
+      span,
+      handle: options.handle,
+      includeActionData: options.includeActionData
+    });
+    span.setStatus({ code: SpanStatusCode.OK });
+  } else {
+    span.setAttribute("robotrock.outcome", outcome);
+    span.setStatus({
+      code: SpanStatusCode.ERROR,
+      message: outcome === "timeout" ? "Human response timed out before validUntil" : "Human wait failed"
+    });
+  }
+  span.end();
+}
+
+// src/otel-platform.ts
+function shouldRecordRobotRockOtel(recordOtel) {
+  if (recordOtel === true) {
+    return true;
+  }
+  if (recordOtel === false) {
+    return false;
+  }
+  const env = process.env.ROBOTROCK_OTEL_RECORD_HANDLED;
+  return env === "true" || env === "1";
+}
+function stripPlatformOtelFields(payload) {
+  const { recordOtel: _recordOtel, otelIncludeActionData: _otelIncludeActionData, ...rest } = payload;
+  return rest;
+}
+function beginRobotRockHumanWaitOtel(task, options = {}) {
+  const recordOtel = shouldRecordRobotRockOtel(options.recordOtel);
+  if (!recordOtel) {
+    return { recordOtel: false };
+  }
+  const handle = captureRobotRockOtelHandle(task);
+  const waitSpan = startRobotRockHumanWaitSpan(handle);
+  return {
+    recordOtel: true,
+    handle,
+    waitSpan,
+    includeActionData: options.otelIncludeActionData
+  };
+}
+function finishRobotRockHumanWaitOtel(session, handled, outcome) {
+  if (!session.recordOtel) {
+    return;
+  }
+  endRobotRockHumanWaitSpan(session.waitSpan, handled, {
+    handle: session.handle,
+    outcome,
+    includeActionData: session.includeActionData
+  });
+}
+
 // src/workflow/index.ts
 var APPROVE_BY_HUMAN_ACTIONS = [
   { id: "approve", title: "Approve" },
@@ -993,6 +1322,7 @@ async function createRobotRockTaskForWebhook(input) {
     baseUrl: baseConfig.baseUrl,
     ...input.app ?? baseConfig.app ? { app: input.app ?? baseConfig.app } : {},
     ...baseConfig.version ? { version: baseConfig.version } : {},
+    ...baseConfig.advanced ? { advanced: baseConfig.advanced } : {},
     webhook: { url: input.webhookUrl }
   });
   return client.sendToHuman({
@@ -1013,7 +1343,7 @@ async function parseRobotRockWebhookRequest(request) {
 async function sendToHumanInWorkflow(payload) {
   var _stack = [];
   try {
-    const { validUntil: validUntilInput, app, ...taskInput } = payload;
+    const { validUntil: validUntilInput, app, recordOtel, otelIncludeActionData, ...taskFields } = payload;
     const { validUntil, timeout } = resolveWaitTiming(validUntilInput);
     const timeoutMs = parseValidUntilMs2(validUntil) - Date.now();
     const webhook = __using(_stack, createWebhook());
@@ -1021,31 +1351,54 @@ async function sendToHumanInWorkflow(payload) {
       webhookUrl: webhook.url,
       app,
       validUntil,
-      taskInput
+      taskInput: stripPlatformOtelFields(taskFields)
     });
-    const outcome = await Promise.race([
-      webhook.then((request) => parseRobotRockWebhookRequest(request)),
-      sleep2(timeoutMs).then(() => ({ timedOut: true }))
-    ]);
-    if ("timedOut" in outcome) {
-      throw new Error(`Human response timed out before validUntil (${timeout})`);
-    }
-    const output = outcome;
-    return toDiscriminatedApprovalResult(payload.actions, {
-      id: output.taskId,
-      createdAt: /* @__PURE__ */ new Date(),
-      status: "handled",
-      context: sendResult.task.context,
-      validUntil: Date.now(),
-      handledAt: new Date(output.handledAt).getTime(),
-      handled: {
-        action: {
-          id: output.action.id,
-          data: output.action.data
-        },
-        handledBy: output.handledBy
-      }
+    const otelSession = beginRobotRockHumanWaitOtel(sendResult.task, {
+      recordOtel,
+      otelIncludeActionData
     });
+    let handledPayload = null;
+    let waitOutcome = "pending";
+    try {
+      const outcome = await Promise.race([
+        webhook.then((request) => parseRobotRockWebhookRequest(request)),
+        sleep2(timeoutMs).then(() => ({ timedOut: true }))
+      ]);
+      if ("timedOut" in outcome) {
+        waitOutcome = "timeout";
+        throw new Error(`Human response timed out before validUntil (${timeout})`);
+      }
+      handledPayload = outcome;
+      waitOutcome = "handled";
+      return toDiscriminatedApprovalResult(payload.actions, {
+        id: outcome.taskId,
+        createdAt: /* @__PURE__ */ new Date(),
+        status: "handled",
+        context: sendResult.task.context,
+        validUntil: Date.now(),
+        handledAt: new Date(outcome.handledAt).getTime(),
+        handled: {
+          action: {
+            id: outcome.action.id,
+            data: outcome.action.data
+          },
+          handledBy: outcome.handledBy
+        }
+      });
+    } catch (error) {
+      if (waitOutcome === "pending") {
+        waitOutcome = "error";
+      }
+      throw error;
+    } finally {
+      if (waitOutcome !== "pending") {
+        finishRobotRockHumanWaitOtel(
+          otelSession,
+          handledPayload,
+          waitOutcome === "handled" ? "handled" : waitOutcome
+        );
+      }
+    }
   } catch (_) {
     var _error = _, _hasError = true;
   } finally {
@@ -1066,9 +1419,10 @@ async function sendRobotRockUpdate(payload) {
     apiKey: baseConfig.apiKey,
     baseUrl: baseConfig.baseUrl,
     ...app ?? baseConfig.app ? { app: app ?? baseConfig.app } : {},
-    ...baseConfig.version ? { version: baseConfig.version } : {}
+    ...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);