robotrock 0.8.5 → 1.0.0

package/dist/ai/index.js

@@ -259,12 +259,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;
     }
@@ -284,6 +284,13 @@ var init_context_urls = __esm({
 
 // ../core/src/schemas/task.ts
 import { z } from "zod";
+function normalizeTaskContextVersion(data) {
+  const { version: legacyVersion, contextVersion, ...rest } = data;
+  return {
+    ...rest,
+    contextVersion: contextVersion ?? legacyVersion ?? TASK_CONTEXT_FORMAT_VERSION
+  };
+}
 function refineContextPublicUrls(data, ctx) {
   const error = validateContextPublicUrls(data.context);
   if (error) {
@@ -294,7 +301,7 @@ function refineContextPublicUrls(data, ctx) {
     });
   }
 }
-var safeUrlSchema, jsonSchema7Schema, uiSchemaSchema, webhookHandlerSchema, triggerHandlerSchema, handlerSchema, taskActionSchema, uiFieldSchemaSchema, contextUiSchema, contextDataSchema, taskContextObjectSchema, taskContextSchema, assignToSchema, threadUpdateMessageSchema, threadUpdateStatuses, threadUpdateStatusSchema, threadUpdateInputSchema, taskPriorities, taskPrioritySchema, nonNegativeInt, agentCostTokensSchema, agentCostSchema, AGENT_INFO_MAX_KEYS, AGENT_TOOL_CALLS_MAX_KEYS, AGENT_OTEL_SPANS_MAX, agentToolCallsSchema, agentOtelSpanStatusSchema, agentOtelSpanSummarySchema, agentOtelSchema, agentTelemetrySchema, createTaskBodySchema;
+var safeUrlSchema, jsonSchema7Schema, uiSchemaSchema, webhookHandlerSchema, triggerHandlerSchema, handlerSchema, taskActionInputSchema, taskActionSchema, uiFieldSchemaSchema, contextUiSchema, contextDataSchema, TASK_CONTEXT_FORMAT_VERSION, taskContextObjectBaseSchema, taskContextObjectSchema, taskContextSchema, assignToSchema, threadUpdateMessageSchema, threadUpdateStatuses, threadUpdateStatusSchema, threadUpdateInputSchema, taskPriorities, taskPrioritySchema, agentTelemetrySchema, createTaskBodySchema, agentChatSeedActionSchema, agentChatSeedMessageSchema, createAgentChatBodySchema, agentChatTransportBodySchema;
 var init_task = __esm({
   "../core/src/schemas/task.ts"() {
     "use strict";
@@ -320,13 +327,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()
     });
@@ -342,7 +351,8 @@ var init_task = __esm({
       data: z.record(z.string(), z.unknown()),
       ui: contextUiSchema
     }).optional();
-    taskContextObjectSchema = z.object({
+    TASK_CONTEXT_FORMAT_VERSION = 2;
+    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),
@@ -350,9 +360,15 @@ var init_task = __esm({
       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")
     });
+    taskContextObjectSchema = taskContextObjectBaseSchema.transform(
+      normalizeTaskContextVersion
+    );
     taskContextSchema = taskContextObjectSchema.superRefine(
       refineContextPublicUrls
     );
@@ -386,61 +402,11 @@ var init_task = __esm({
     });
     taskPriorities = ["low", "normal", "high", "urgent"];
     taskPrioritySchema = z.enum(taskPriorities);
-    nonNegativeInt = z.number().int().nonnegative();
-    agentCostTokensSchema = z.object({
-      input: nonNegativeInt.optional(),
-      output: nonNegativeInt.optional(),
-      total: nonNegativeInt.optional()
-    });
-    agentCostSchema = z.object({
-      tokens: agentCostTokensSchema.optional(),
-      eur: z.number().nonnegative().optional(),
-      usd: z.number().nonnegative().optional()
-    });
-    AGENT_INFO_MAX_KEYS = 32;
-    AGENT_TOOL_CALLS_MAX_KEYS = 64;
-    AGENT_OTEL_SPANS_MAX = 32;
-    agentToolCallsSchema = z.record(z.string().min(1), nonNegativeInt);
-    agentOtelSpanStatusSchema = z.enum(["ok", "error"]);
-    agentOtelSpanSummarySchema = z.object({
-      name: z.string().min(1),
-      durationMs: z.number().nonnegative(),
-      status: agentOtelSpanStatusSchema
-    });
-    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()
-    });
     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`
-      }
-    );
-    createTaskBodySchema = taskContextObjectSchema.extend({
+      version: z.string().min(1)
+    });
+    createTaskBodySchema = taskContextObjectBaseSchema.extend({
       assignTo: assignToSchema.optional(),
       /**
        * Groups related tasks together. When omitted, the server generates one and
@@ -457,9 +423,59 @@ var init_task = __esm({
        * 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);
+    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()
+    });
+    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"
+    });
+    agentChatTransportBodySchema = z.object({
+      chatId: z.string().min(1),
+      publicAccessToken: z.string().min(1),
+      lastEventId: z.string().optional(),
+      isStreaming: z.boolean().optional()
+    });
   }
 });
 
@@ -482,6 +498,13 @@ var init_schemas = __esm({
 
 // src/schemas/index.ts
 import { z as z2 } from "zod";
+function normalizeTaskContextVersion2(data) {
+  const { version: legacyVersion, contextVersion, ...rest } = data;
+  return {
+    ...rest,
+    contextVersion: contextVersion ?? legacyVersion ?? TASK_CONTEXT_FORMAT_VERSION2
+  };
+}
 function refineContextPublicUrls2(data, ctx) {
   const error = validateContextPublicUrls(data.context);
   if (error) {
@@ -492,7 +515,7 @@ function refineContextPublicUrls2(data, ctx) {
     });
   }
 }
-var safeUrlSchema2, jsonSchema7Schema2, uiSchemaSchema2, webhookHandlerSchema2, triggerHandlerSchema2, handlerSchema2, taskActionSchema2, uiFieldSchemaSchema2, contextUiSchema2, contextDataSchema2, taskContextObjectSchema2, taskContextSchema2, assignToSchema2, threadUpdateMessageSchema2, threadUpdateStatuses2, threadUpdateStatusSchema2, threadUpdateInputSchema2, taskPriorities2, taskPrioritySchema2, nonNegativeInt2, agentCostTokensSchema2, agentCostSchema2, AGENT_INFO_MAX_KEYS2, AGENT_TOOL_CALLS_MAX_KEYS2, AGENT_OTEL_SPANS_MAX2, agentToolCallsSchema2, agentOtelSpanStatusSchema2, agentOtelSpanSummarySchema2, agentOtelSchema2, agentTelemetrySchema2, createTaskBodySchema2, threadUpdateBodySchema;
+var safeUrlSchema2, jsonSchema7Schema2, uiSchemaSchema2, webhookHandlerSchema2, triggerHandlerSchema2, handlerSchema2, taskActionInputSchema2, taskActionSchema2, uiFieldSchemaSchema2, contextUiSchema2, contextDataSchema2, TASK_CONTEXT_FORMAT_VERSION2, taskContextObjectBaseSchema2, taskContextObjectSchema2, taskContextSchema2, assignToSchema2, threadUpdateMessageSchema2, threadUpdateStatuses2, threadUpdateStatusSchema2, threadUpdateInputSchema2, taskPriorities2, taskPrioritySchema2, agentTelemetrySchema2, createTaskBodySchema2, threadUpdateBodySchema;
 var init_schemas2 = __esm({
   "src/schemas/index.ts"() {
     "use strict";
@@ -518,13 +541,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({
@@ -539,16 +564,22 @@ var init_schemas2 = __esm({
       data: z2.record(z2.string(), z2.unknown()),
       ui: contextUiSchema2
     }).optional();
-    taskContextObjectSchema2 = z2.object({
+    TASK_CONTEXT_FORMAT_VERSION2 = 2;
+    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")
     });
+    taskContextObjectSchema2 = taskContextObjectBaseSchema2.transform(
+      normalizeTaskContextVersion2
+    );
     taskContextSchema2 = taskContextObjectSchema2.superRefine(
       refineContextPublicUrls2
     );
@@ -582,56 +613,10 @@ var init_schemas2 = __esm({
     });
     taskPriorities2 = ["low", "normal", "high", "urgent"];
     taskPrioritySchema2 = z2.enum(taskPriorities2);
-    nonNegativeInt2 = z2.number().int().nonnegative();
-    agentCostTokensSchema2 = z2.object({
-      input: nonNegativeInt2.optional(),
-      output: nonNegativeInt2.optional(),
-      total: nonNegativeInt2.optional()
-    });
-    agentCostSchema2 = z2.object({
-      tokens: agentCostTokensSchema2.optional(),
-      eur: z2.number().nonnegative().optional(),
-      usd: z2.number().nonnegative().optional()
-    });
-    AGENT_INFO_MAX_KEYS2 = 32;
-    AGENT_TOOL_CALLS_MAX_KEYS2 = 64;
-    AGENT_OTEL_SPANS_MAX2 = 32;
-    agentToolCallsSchema2 = z2.record(z2.string().min(1), nonNegativeInt2);
-    agentOtelSpanStatusSchema2 = z2.enum(["ok", "error"]);
-    agentOtelSpanSummarySchema2 = z2.object({
-      name: z2.string().min(1),
-      durationMs: z2.number().nonnegative(),
-      status: agentOtelSpanStatusSchema2
-    });
-    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()
-    });
     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`
-      }
-    );
-    createTaskBodySchema2 = taskContextObjectSchema2.extend({
+      version: z2.string().min(1)
+    });
+    createTaskBodySchema2 = taskContextObjectBaseSchema2.extend({
       assignTo: assignToSchema2.optional(),
       /**
        * Groups related tasks together. When omitted, the server generates one and
@@ -649,7 +634,7 @@ var init_schemas2 = __esm({
        */
       update: threadUpdateInputSchema2.optional(),
       agent: agentTelemetrySchema2.optional()
-    }).superRefine(refineContextPublicUrls2);
+    }).transform(normalizeTaskContextVersion2).superRefine(refineContextPublicUrls2);
     threadUpdateBodySchema = threadUpdateInputSchema2;
   }
 });
@@ -687,10 +672,248 @@ 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 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 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
+var PRODUCTION_APP_URL, APP_SIGNUP_URL;
+var init_app_url = __esm({
+  "../core/src/app-url.ts"() {
+    "use strict";
+    PRODUCTION_APP_URL = "https://app.robotrock.io";
+    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/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();
+  }
+});
+
+// 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
+        );
+      }
+    }
+  };
+}
+var init_chats = __esm({
+  "src/chats.ts"() {
+    "use strict";
+    init_src();
+    init_http();
+  }
+});
+
 // src/client.ts
 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;
@@ -744,6 +967,7 @@ function normalizeSendToHumanInput(task2, clientDefaults) {
     threadId: _threadId,
     priority: _priority,
     update: _update,
+    version: _version,
     validUntil,
     app: taskApp,
     ...rest
@@ -753,67 +977,35 @@ function normalizeSendToHumanInput(task2, 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;
-}
-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_chats();
+    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;
       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(
@@ -830,26 +1022,37 @@ var init_client = __esm({
         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: (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,
-          version: this.version
+          contextVersion: this.contextVersion,
+          agentVersion: this.agentVersion
         });
+        const agentVersion = task2.version ?? this.agentVersion;
         const bodyPayload = {
           ...normalizedTask,
           ...task2.assignTo !== void 0 ? { assignTo: task2.assignTo } : {},
           ...task2.threadId !== void 0 ? { threadId: task2.threadId } : {},
           ...task2.priority !== void 0 ? { priority: task2.priority } : {},
           ...task2.update !== void 0 ? { update: task2.update } : {},
-          ...task2.agent !== void 0 ? { agent: task2.agent } : {}
+          ...agentVersion !== void 0 ? { agent: { version: agentVersion } } : {}
         };
         const validation = createTaskBodySchema2.safeParse(bodyPayload);
         if (!validation.success) {
@@ -885,9 +1088,10 @@ var init_client = __esm({
         const normalizedTask = normalizeSendToHumanInput(task2, {
           webhook: this.webhook,
           app: this.app,
-          version: this.version
+          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
         );
@@ -904,7 +1108,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",
@@ -926,10 +1130,35 @@ 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: {
@@ -949,11 +1178,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);
         }
@@ -986,7 +1215,7 @@ 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: {
@@ -1027,6 +1256,212 @@ var init_env = __esm({
   }
 });
 
+// src/record-handled-to-otel.ts
+import {
+  context,
+  trace,
+  SpanStatusCode
+} from "@opentelemetry/api";
+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(task2, options) {
+  const spanCtx = resolveSpanContext(options?.span);
+  return {
+    traceId: spanCtx?.traceId ?? "",
+    spanId: spanCtx?.spanId ?? "",
+    taskId: task2.taskId,
+    threadId: task2.threadId,
+    taskCreatedAt: parseTaskCreatedAt(task2.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();
+}
+var TRACER_NAME, WAIT_SPAN_NAME, HANDLED_EVENT_NAME, INVALID_TRACE_ID;
+var init_record_handled_to_otel = __esm({
+  "src/record-handled-to-otel.ts"() {
+    "use strict";
+    TRACER_NAME = "robotrock";
+    WAIT_SPAN_NAME = "robotrock.wait_for_human";
+    HANDLED_EVENT_NAME = "robotrock.task_handled";
+    INVALID_TRACE_ID = "00000000000000000000000000000000";
+  }
+});
+
+// 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(task2, options = {}) {
+  const recordOtel = shouldRecordRobotRockOtel(options.recordOtel);
+  if (!recordOtel) {
+    return { recordOtel: false };
+  }
+  const handle = captureRobotRockOtelHandle(task2);
+  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
+  });
+}
+var init_otel_platform = __esm({
+  "src/otel-platform.ts"() {
+    "use strict";
+    init_record_handled_to_otel();
+  }
+});
+
 // src/handler-webhook.ts
 function isRobotRockHandlerWebhookPayload(value) {
   if (typeof value !== "object" || value === null) {
@@ -1107,7 +1542,7 @@ __export(trigger_exports, {
 });
 import { task, wait } from "@trigger.dev/sdk";
 async function runSendToHuman(payload) {
-  const { validUntil: validUntilInput, ...taskInput } = payload;
+  const { validUntil: validUntilInput, app, recordOtel, otelIncludeActionData, ...taskFields } = payload;
   const { validUntil, timeout } = resolveWaitTiming(validUntilInput);
   const token = await wait.createToken({ timeout });
   const baseConfig = resolveRobotRockConfig();
@@ -1116,45 +1551,74 @@ async function runSendToHuman(payload) {
     baseUrl: baseConfig.baseUrl,
     ...baseConfig.app ? { app: baseConfig.app } : {},
     ...baseConfig.version ? { version: baseConfig.version } : {},
+    ...baseConfig.advanced ? { advanced: baseConfig.advanced } : {},
     webhook: { url: token.url }
   });
+  const taskInput = stripPlatformOtelFields(taskFields);
   const sendResult = await client.sendToHuman({
     ...taskInput,
-    validUntil
+    validUntil,
+    ...app !== void 0 ? { app } : {}
   });
-  const outcome = await wait.forToken(token.id);
-  if (!outcome.ok) {
-    throw new Error(`Human response timed out before validUntil (${timeout})`);
-  }
-  const output = outcome.output;
-  if (!isRobotRockHandlerWebhookPayload(output)) {
-    throw new Error(
-      "Wait token completed with unexpected payload; expected RobotRock handler body (taskId, action.id, action.data)."
-    );
-  }
-  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 wait.forToken(token.id);
+    if (!outcome.ok) {
+      waitOutcome = "timeout";
+      throw new Error(`Human response timed out before validUntil (${timeout})`);
+    }
+    const output = outcome.output;
+    if (!isRobotRockHandlerWebhookPayload(output)) {
+      waitOutcome = "error";
+      throw new Error(
+        "Wait token completed with unexpected payload; expected RobotRock handler body (taskId, action.id, action.data)."
+      );
+    }
+    handledPayload = output;
+    waitOutcome = "handled";
+    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
+        }
       }
+    );
+  } catch (error) {
+    if (waitOutcome === "pending") {
+      waitOutcome = "error";
     }
-  );
+    throw error;
+  } finally {
+    if (waitOutcome !== "pending") {
+      finishRobotRockHumanWaitOtel(
+        otelSession,
+        handledPayload,
+        waitOutcome === "handled" ? "handled" : waitOutcome
+      );
+    }
+  }
 }
 var APPROVE_BY_HUMAN_ACTIONS, sendToHumanTask, approveByHumanTask;
 var init_trigger = __esm({
   "src/trigger/index.ts"() {
     "use strict";
+    init_otel_platform();
     init_client();
     init_env();
     init_approval_result();
@@ -1194,6 +1658,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({
@@ -1214,7 +1679,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());
@@ -1222,31 +1687,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 {
@@ -1267,9 +1755,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);
@@ -1283,6 +1772,7 @@ var init_workflow = __esm({
     init_approval_result();
     init_handler_webhook();
     init_wait_timing();
+    init_otel_platform();
     APPROVE_BY_HUMAN_ACTIONS2 = [
       { id: "approve", title: "Approve" },
       { id: "decline", title: "Decline" }
@@ -1294,7 +1784,7 @@ var init_workflow = __esm({
 import { tool } from "ai";
 
 // 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();
@@ -1327,27 +1817,27 @@ function normalizeRobotRockAiContext(clientOrContext) {
   }
   throw new Error(`Unknown RobotRock AI mode: ${String(clientOrContext.mode)}`);
 }
-async function sendToHumanForAi(context, payload) {
-  if (context.mode === "trigger") {
+async function sendToHumanForAi(context2, payload) {
+  if (context2.mode === "trigger") {
     const { sendToHumanTask: sendToHumanTask2 } = await Promise.resolve().then(() => (init_trigger(), trigger_exports));
     const waitResult = await sendToHumanTask2.triggerAndWait({
       ...payload,
-      ...context.app ? { app: context.app } : {}
+      ...context2.app ? { app: context2.app } : {}
     });
     if (!waitResult.ok) {
       throw waitResult.error;
     }
     return waitResult.output;
   }
-  if (context.mode === "workflow") {
+  if (context2.mode === "workflow") {
     const { sendToHumanInWorkflow: sendToHumanInWorkflow2 } = await Promise.resolve().then(() => (init_workflow(), workflow_exports));
     const result2 = await sendToHumanInWorkflow2({
       ...payload,
-      ...context.app ? { app: context.app } : {}
+      ...context2.app ? { app: context2.app } : {}
     });
     return result2;
   }
-  const result = await context.client.sendToHuman(payload);
+  const result = await context2.client.sendToHuman(payload);
   if (result.mode !== "handled") {
     throw new Error(
       "RobotRock task was created but not handled. Configure client polling or webhook, or use mode: 'trigger' / 'workflow' for durable waits."
@@ -1361,42 +1851,52 @@ async function sendToHumanForAi(context, payload) {
     taskId: result.taskId
   };
 }
-async function sendUpdateForAi(context, payload) {
-  if (context.mode === "workflow") {
+async function sendUpdateForAi(context2, payload) {
+  if (context2.mode === "workflow") {
     const { sendUpdateInWorkflow: sendUpdateInWorkflow2 } = await Promise.resolve().then(() => (init_workflow(), workflow_exports));
     return sendUpdateInWorkflow2({
       ...payload,
-      ...context.app ? { app: context.app } : {}
+      ...context2.app ? { app: context2.app } : {}
     });
   }
-  if (context.mode === "trigger") {
+  if (context2.mode === "trigger") {
+    const client = createClient(
+      resolveRobotRockConfig(context2.app ? { app: context2.app } : void 0)
+    );
+    return client.tasks.sendUpdate(payload);
+  }
+  return context2.client.tasks.sendUpdate(payload);
+}
+async function closeChatForAi(context2, payload) {
+  if (context2.mode === "trigger" || context2.mode === "workflow") {
     const client = createClient(
-      resolveRobotRockConfig(context.app ? { app: context.app } : void 0)
+      resolveRobotRockConfig(context2.app ? { app: context2.app } : void 0)
     );
-    return client.sendUpdate(payload);
+    await client.chats.close(payload.chatId, { reason: payload.reason });
+    return;
   }
-  return context.client.sendUpdate(payload);
+  await context2.client.chats.close(payload.chatId, { reason: payload.reason });
 }
-async function approveByHumanForAi(context, payload) {
-  if (context.mode === "trigger") {
+async function approveByHumanForAi(context2, payload) {
+  if (context2.mode === "trigger") {
     const { approveByHumanTask: approveByHumanTask2 } = await Promise.resolve().then(() => (init_trigger(), trigger_exports));
     const waitResult = await approveByHumanTask2.triggerAndWait({
       ...payload,
-      ...context.app ? { app: context.app } : {}
+      ...context2.app ? { app: context2.app } : {}
     });
     if (!waitResult.ok) {
       throw waitResult.error;
     }
     return waitResult.output;
   }
-  if (context.mode === "workflow") {
+  if (context2.mode === "workflow") {
     const { approveByHumanInWorkflow: approveByHumanInWorkflow2 } = await Promise.resolve().then(() => (init_workflow(), workflow_exports));
     return await approveByHumanInWorkflow2({
       ...payload,
-      ...context.app ? { app: context.app } : {}
+      ...context2.app ? { app: context2.app } : {}
     });
   }
-  const result = await context.client.sendToHuman({
+  const result = await context2.client.sendToHuman({
     ...payload,
     actions: APPROVE_BY_HUMAN_ACTIONS3
   });
@@ -1438,11 +1938,11 @@ var APPROVE_BY_HUMAN_ACTIONS4 = [
   { id: "approve", title: "Approve" },
   { id: "decline", title: "Decline" }
 ];
-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");
@@ -1492,16 +1992,16 @@ import { tool as tool2 } from "ai";
 
 // 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"
   )
@@ -1555,12 +2055,12 @@ import { tool as tool3 } from "ai";
 // 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"
   )
@@ -1616,17 +2116,185 @@ function createSendUpdateTool(clientOrOptions, maybeOptions = {}) {
   return tool3(buildSendUpdateToolDefinition(clientOrOptions, maybeOptions));
 }
 
+// src/ai/request-action-input-tool.ts
+import { tool as tool4 } from "ai";
+
+// src/ai/request-action-input-tool-core.ts
+import { z as z7 } from "zod";
+var REQUEST_ACTION_INPUT_TOOL_NAME = "requestActionInput";
+function defaultRequestActionInputActionId(title) {
+  const slug = title.trim().toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug.length > 0 ? slug : "submit";
+}
+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")
+});
+function normalizeRequestActionInputToolInput(input) {
+  const parsed = requestActionInputToolInputSchema.parse(input);
+  return {
+    ...parsed,
+    action: {
+      ...parsed.action,
+      id: parsed.action.id?.trim() || defaultRequestActionInputActionId(parsed.action.title)
+    }
+  };
+}
+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
+  };
+}
+function isRequestActionInputToolPart(part, toolName = REQUEST_ACTION_INPUT_TOOL_NAME) {
+  return part.type === `tool-${toolName}`;
+}
+
+// src/ai/request-action-input-tool.ts
+function requestActionInputTool(options = {}) {
+  const definition = buildRequestActionInputToolDefinition(options);
+  return tool4(definition);
+}
+
+// src/ai/report-status-tool.ts
+import { tool as tool5 } from "ai";
+
+// src/ai/report-status-tool-core.ts
+import { z as z8 } from "zod";
+var REPORT_STATUS_TOOL_NAME = "reportStatus";
+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
+  };
+}
+function isReportStatusToolPart(part, toolName = REPORT_STATUS_TOOL_NAME) {
+  return part.type === `tool-${toolName}`;
+}
+
+// src/ai/report-status-tool.ts
+function reportStatusTool(options = {}) {
+  return tool5(buildReportStatusToolDefinition(options));
+}
+
+// src/ai/close-chat-tool.ts
+import { tool as tool6 } from "ai";
+
+// src/ai/close-chat-tool-core.ts
+import { z as z9 } from "zod";
+var CLOSE_CHAT_TOOL_NAME = "closeChat";
+var closeChatToolInputSchema = z9.object({
+  reason: z9.string().optional().describe(
+    "Short reason the conversation is being closed (recorded on the audit trail)."
+  )
+});
+function resolveCloseChatToolConfig(clientOrOptions, maybeOptions) {
+  const isDurable = typeof clientOrOptions === "object" && clientOrOptions !== null && "mode" in clientOrOptions && (clientOrOptions.mode === "trigger" || clientOrOptions.mode === "workflow");
+  const aiContext = normalizeRobotRockAiContext(
+    isDurable ? {
+      mode: clientOrOptions.mode,
+      app: clientOrOptions.app
+    } : clientOrOptions
+  );
+  const options = isDurable ? clientOrOptions : maybeOptions;
+  if (!options?.chatId) {
+    throw new Error(
+      "closeChatTool: `chatId` is required. Pass the chatId of the chat the agent is running in."
+    );
+  }
+  return { aiContext, options };
+}
+function buildCloseChatToolDefinition(clientOrOptions, maybeOptions) {
+  const { aiContext, options } = resolveCloseChatToolConfig(
+    clientOrOptions,
+    maybeOptions
+  );
+  const description = options.description ?? "Close the current chat when the conversation is complete and no further human input is needed. Records the close on the audit trail.";
+  return {
+    description,
+    inputSchema: closeChatToolInputSchema,
+    execute: async (input) => {
+      await closeChatForAi(aiContext, {
+        chatId: options.chatId,
+        reason: input.reason
+      });
+      return { closed: true, chatId: options.chatId };
+    }
+  };
+}
+
+// src/ai/close-chat-tool.ts
+function closeChatTool(clientOrOptions, maybeOptions) {
+  return tool6(buildCloseChatToolDefinition(clientOrOptions, maybeOptions));
+}
+
 // src/ai/create-ai-tools.ts
 function createRobotRockAiTools(options) {
   const mode = options.mode ?? (options.client ? "polling" : "trigger");
   if (mode === "polling" && !options.client) {
     throw new Error("createRobotRockAiTools: polling mode requires `client`.");
   }
-  const context = mode === "trigger" ? { mode: "trigger", app: options.app } : mode === "workflow" ? { mode: "workflow", app: options.app } : { mode: "polling", client: options.client };
-  const durableContext = context.mode === "trigger" || context.mode === "workflow" ? context : null;
-  const pollingClient = context.mode === "polling" ? context.client : void 0;
+  const context2 = mode === "trigger" ? { mode: "trigger", app: options.app } : mode === "workflow" ? { mode: "workflow", app: options.app } : { mode: "polling", client: options.client };
+  const durableContext = context2.mode === "trigger" || context2.mode === "workflow" ? context2 : null;
+  const pollingClient = context2.mode === "polling" ? context2.client : void 0;
   return {
-    context,
+    context: context2,
     approveByHuman: (toolOptions) => durableContext ? approveByHumanTool({ ...durableContext, ...toolOptions }) : approveByHumanTool(pollingClient, toolOptions),
     sendToHuman: (toolOptions) => durableContext ? createSendToHumanTool({
       ...durableContext,
@@ -1643,7 +2311,19 @@ function createRobotRockAiTools(options) {
     }) : createSendUpdateTool(pollingClient, {
       ...options.threadId ? { threadId: options.threadId } : {},
       ...toolOptions
-    })
+    }),
+    requestActionInput: (toolOptions = {}) => requestActionInputTool(toolOptions),
+    reportStatus: (toolOptions = {}) => reportStatusTool(toolOptions),
+    closeChat: (toolOptions) => {
+      const chatId = toolOptions?.chatId ?? options.chatId;
+      if (!chatId) {
+        throw new Error(
+          "createRobotRockAiTools: closeChat requires `chatId`. Pass it on `createRobotRockAiTools({ chatId })` or `closeChat({ chatId })`."
+        );
+      }
+      const resolvedOptions = { ...toolOptions, chatId };
+      return durableContext ? closeChatTool({ ...durableContext, ...resolvedOptions }) : closeChatTool(pollingClient, resolvedOptions);
+    }
   };
 }
 
@@ -1655,12 +2335,6 @@ var DEFAULT_APPROVE_ACTIONS = [
 function defaultFormatToolApprovalTask(toolCall, options = {}) {
   const approveId = options.approveActionId ?? "approve";
   const denyId = options.denyActionId ?? "deny";
-  let inputPreview;
-  try {
-    inputPreview = JSON.stringify(toolCall.input, null, 2);
-  } catch {
-    inputPreview = String(toolCall.input);
-  }
   return {
     type: options.type ?? "ai-tool-approval",
     name: `Approve: ${toolCall.toolName}`,
@@ -1858,7 +2532,7 @@ function resolveToolCallForRequest(request, source, messages) {
   );
 }
 async function resolveToolApprovalsViaRobotRock(clientOrContext, source, options = {}) {
-  const context = normalizeRobotRockAiContext(clientOrContext);
+  const context2 = normalizeRobotRockAiContext(clientOrContext);
   const approveId = options.approveActionId ?? "approve";
   const denyId = options.denyActionId ?? "deny";
   const formatTask = options.formatTask ?? defaultFormatToolApprovalTask;
@@ -1871,7 +2545,7 @@ async function resolveToolApprovalsViaRobotRock(clientOrContext, source, options
       approveActionId: approveId,
       denyActionId: denyId
     });
-    const result = await sendToHumanForAi(context, taskInput);
+    const result = await sendToHumanForAi(context2, taskInput);
     const approved = result.actionId === approveId;
     const reason = typeof result.data === "object" && result.data !== null && "reason" in result.data && typeof result.data.reason === "string" ? result.data.reason : approved ? "Approved in RobotRock inbox" : "Denied in RobotRock inbox";
     responses.push({
@@ -1910,11 +2584,19 @@ async function runWithRobotRockApprovals(options) {
 }
 export {
   APPROVE_BY_HUMAN_ACTIONS4 as APPROVE_BY_HUMAN_ACTIONS,
+  CLOSE_CHAT_TOOL_NAME,
   DEFAULT_APPROVE_ACTIONS,
+  REPORT_STATUS_TOOL_NAME,
+  REQUEST_ACTION_INPUT_TOOL_NAME,
   applyRobotRockToolApprovalToTools,
   approveByHumanForAi,
   approveByHumanInputSchema,
   approveByHumanTool,
+  buildReportStatusToolDefinition,
+  buildRequestActionInputToolDefinition,
+  closeChatForAi,
+  closeChatTool,
+  closeChatToolInputSchema,
   collectApprovalRequests,
   createRobotRockAiTools,
   createRobotRockAiTriggerContext,
@@ -1924,7 +2606,20 @@ export {
   createSendToHumanTool,
   createSendUpdateTool,
   defaultFormatToolApprovalTask,
+  defaultRequestActionInputActionId,
+  executeReportStatusTool,
+  isReportStatusToolPart,
+  isRequestActionInputToolPart,
+  normalizeReportStatusToolInput,
+  normalizeRequestActionInputToolInput,
   normalizeRobotRockAiContext,
+  reportStatusPhaseSchema,
+  reportStatusTool,
+  reportStatusToolInputSchema,
+  reportStatusToolOutputSchema,
+  requestActionInputTool,
+  requestActionInputToolInputSchema,
+  requestActionInputToolOutputSchema,
   resolveToolApprovalsViaRobotRock,
   runWithRobotRockApprovals,
   sendToHumanForAi,