robotrock 0.9.0 → 1.0.0

package/dist/ai/trigger.js

@@ -301,7 +301,7 @@ function refineContextPublicUrls(data, ctx) {
     });
   }
 }
-var safeUrlSchema, jsonSchema7Schema, uiSchemaSchema, webhookHandlerSchema, triggerHandlerSchema, handlerSchema, taskActionSchema, uiFieldSchemaSchema, contextUiSchema, contextDataSchema, TASK_CONTEXT_FORMAT_VERSION, taskContextObjectBaseSchema, taskContextObjectSchema, taskContextSchema, assignToSchema, threadUpdateMessageSchema, threadUpdateStatuses, threadUpdateStatusSchema, threadUpdateInputSchema, taskPriorities, taskPrioritySchema, agentTelemetrySchema, createTaskBodySchema;
+var safeUrlSchema, 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";
@@ -327,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()
     });
@@ -424,6 +426,56 @@ var init_task = __esm({
       /** Agent release version — not shown in inbox UI. */
       agent: agentTelemetrySchema.optional()
     }).transform(normalizeTaskContextVersion).superRefine(refineContextPublicUrls);
+    agentChatSeedActionSchema = z.object({
+      /** Stable action id echoed back on submit; auto-derived from title when omitted. */
+      id: z.string().min(1).optional(),
+      title: z.string().min(1),
+      description: z.string().optional(),
+      /** JSON Schema object for the form fields. */
+      schema: z.record(z.string(), z.unknown()).optional(),
+      /** RJSF ui schema overrides (ui:widget, ui:enumNames, etc.). */
+      ui: z.record(z.string(), z.unknown()).optional(),
+      /** Optional default field values. */
+      data: z.record(z.string(), z.unknown()).optional()
+    });
+    agentChatSeedMessageSchema = z.object({
+      role: z.enum(["user", "assistant"]),
+      text: z.string().min(1),
+      /** Optional display-name override for the message sender. */
+      senderName: z.string().min(1).optional(),
+      /**
+       * Optional structured input request rendered as a styled RobotRock action
+       * widget below the message text. Use this instead of asking the user to reply
+       * in plain text so the request is always a proper action form.
+       */
+      requestActionInput: z.object({
+        prompt: z.string().optional(),
+        action: agentChatSeedActionSchema
+      }).optional()
+    });
+    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()
+    });
   }
 });
 
@@ -463,7 +515,7 @@ function refineContextPublicUrls2(data, ctx) {
     });
   }
 }
-var safeUrlSchema2, jsonSchema7Schema2, uiSchemaSchema2, webhookHandlerSchema2, triggerHandlerSchema2, handlerSchema2, taskActionSchema2, uiFieldSchemaSchema2, contextUiSchema2, contextDataSchema2, TASK_CONTEXT_FORMAT_VERSION2, taskContextObjectBaseSchema2, taskContextObjectSchema2, taskContextSchema2, assignToSchema2, threadUpdateMessageSchema2, threadUpdateStatuses2, threadUpdateStatusSchema2, threadUpdateInputSchema2, taskPriorities2, taskPrioritySchema2, agentTelemetrySchema2, createTaskBodySchema2, threadUpdateBodySchema;
+var 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";
@@ -489,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({
@@ -618,6 +672,240 @@ 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));
@@ -695,54 +983,17 @@ function normalizeSendToHumanInput(task2, clientDefaults) {
     actions: normalizedActions
   };
 }
-async function parseResponseBody(response) {
-  const contentType = response.headers.get("content-type") ?? "";
-  const bodyText = await response.text();
-  if (!bodyText) {
-    return null;
-  }
-  if (contentType.toLowerCase().includes("application/json")) {
-    try {
-      return JSON.parse(bodyText);
-    } catch {
-    }
-  }
-  try {
-    return JSON.parse(bodyText);
-  } catch {
-    return bodyText;
-  }
-}
-function getErrorMessage(data, fallback) {
-  if (data && typeof data === "object" && !Array.isArray(data)) {
-    const maybeMessage = data.message;
-    if (typeof maybeMessage === "string" && maybeMessage.trim()) {
-      return maybeMessage;
-    }
-  }
-  if (typeof data === "string" && data.trim()) {
-    const compact = data.replace(/\s+/g, " ").trim();
-    const snippet = compact.length > 180 ? `${compact.slice(0, 180)}...` : compact;
-    return `${fallback}. Server returned non-JSON response: ${snippet}`;
-  }
-  return fallback;
-}
-var DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS, RobotRockError, RobotRock;
+var DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS, RobotRock;
 var init_client = __esm({
   "src/client.ts"() {
     "use strict";
     init_schemas2();
     init_approval_result();
+    init_http();
+    init_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;
@@ -751,6 +1002,10 @@ var init_client = __esm({
       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(
@@ -771,11 +1026,19 @@ var init_client = __esm({
         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,
@@ -828,7 +1091,7 @@ var init_client = __esm({
           contextVersion: this.contextVersion,
           agentVersion: this.agentVersion
         });
-        const createdTaskTask = await this.createTask(task2);
+        const createdTaskTask = await this.createTaskRequest(task2);
         const hasHandlers = normalizedTask.actions.some(
           (action) => Array.isArray(action.handlers) && action.handlers.length > 0
         );
@@ -845,7 +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",
@@ -867,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: {
@@ -890,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);
         }
@@ -927,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: {
@@ -1470,7 +1758,7 @@ async function sendRobotRockUpdate(payload) {
     ...baseConfig.version ? { version: baseConfig.version } : {},
     ...baseConfig.advanced ? { advanced: baseConfig.advanced } : {}
   });
-  return client.sendUpdate(update);
+  return client.tasks.sendUpdate(update);
 }
 async function sendUpdateInWorkflow(payload) {
   return sendRobotRockUpdate(payload);
@@ -1496,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();
@@ -1572,9 +1860,19 @@ async function sendUpdateForAi(context2, payload) {
     const client = createClient(
       resolveRobotRockConfig(context2.app ? { app: context2.app } : void 0)
     );
-    return client.sendUpdate(payload);
+    return client.tasks.sendUpdate(payload);
+  }
+  return context2.client.tasks.sendUpdate(payload);
+}
+async function closeChatForAi(context2, payload) {
+  if (context2.mode === "trigger" || context2.mode === "workflow") {
+    const client = createClient(
+      resolveRobotRockConfig(context2.app ? { app: context2.app } : void 0)
+    );
+    await client.chats.close(payload.chatId, { reason: payload.reason });
+    return;
   }
-  return context2.client.sendUpdate(payload);
+  await context2.client.chats.close(payload.chatId, { reason: payload.reason });
 }
 async function approveByHumanForAi(context2, payload) {
   if (context2.mode === "trigger") {
@@ -1633,11 +1931,11 @@ function toHumanToolResult(result) {
 }
 
 // src/ai/approve-by-human-tool-core.ts
-var approveByHumanInputSchema = z3.object({
-  type: z3.string().optional().describe("Task type slug; defaults to ai-approval"),
-  name: z3.string().describe("Short title for the approval request"),
-  description: z3.string().describe("What needs approval and the consequences of approving or declining"),
-  contextSummary: z3.string().optional().describe("Optional markdown summary shown to the reviewer")
+var approveByHumanInputSchema = z4.object({
+  type: z4.string().optional().describe("Task type slug; defaults to ai-approval"),
+  name: z4.string().describe("Short title for the approval request"),
+  description: z4.string().describe("What needs approval and the consequences of approving or declining"),
+  contextSummary: z4.string().optional().describe("Optional markdown summary shown to the reviewer")
 });
 function resolveApproveByHumanToolConfig(clientOrContext, maybeOptions = {}) {
   const isDurable = typeof clientOrContext === "object" && clientOrContext !== null && "mode" in clientOrContext && (clientOrContext.mode === "trigger" || clientOrContext.mode === "workflow");
@@ -1687,16 +1985,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"
   )
@@ -1750,12 +2048,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"
   )
@@ -1811,6 +2109,101 @@ 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 requestActionInputActionSchema = z7.object({
+  id: z7.string().min(1).optional().describe(
+    "Stable action identifier echoed in tool output (e.g. pick-blog-topic). Strongly recommended \u2014 auto-derived from title when omitted."
+  ),
+  title: z7.string().min(1),
+  description: z7.string().optional(),
+  schema: z7.record(z7.string(), z7.unknown()).optional().describe("JSON Schema object for the human feedback form"),
+  ui: z7.record(z7.string(), z7.unknown()).optional().describe(
+    'RJSF ui schema overrides (ui:widget, ui:enumNames, etc.). Use ui:widget "radio" for 2\u20136 discrete choices rendered as tappable cards.'
+  ),
+  data: z7.record(z7.string(), z7.unknown()).optional().describe("Optional default form field values")
+});
+var requestActionInputToolOutputSchema = z7.object({
+  actionId: z7.string().min(1),
+  data: z7.record(z7.string(), z7.unknown())
+});
+var requestActionInputToolInputSchema = z7.object({
+  prompt: z7.string().optional().describe("Optional heading shown above the action widget in chat"),
+  action: requestActionInputActionSchema.describe(
+    "Action widget config: JSON Schema form fields and optional RJSF ui overrides (same shape as RobotRock inbox actions)"
+  )
+});
+function buildRequestActionInputToolDefinition(options = {}) {
+  const description = options.description ?? `Ask the user for structured input via a RobotRock action widget in chat. Always set action.id (e.g. "pick-blog-topic") and action.title. Provide action.schema and optional action.ui using the same JSON Schema and RJSF ui shape as inbox action widgets. Put every field you need in a single call \u2014 never invoke this tool more than once per turn. For 2\u20136 discrete options, use a string enum with ui:widget "radio" and ui:enumNames \u2014 never markdown bullet lists. After the tool returns, act on the user's data immediately; do not ask them to confirm choices they already submitted.`;
+  return {
+    description,
+    inputSchema: requestActionInputToolInputSchema,
+    outputSchema: requestActionInputToolOutputSchema
+  };
+}
+
+// src/ai/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 reportStatusPhaseSchema = z8.enum([
+  "info",
+  "running",
+  "waiting",
+  "succeeded",
+  "failed"
+]);
+var reportStatusToolInputSchema = z8.object({
+  message: z8.string().min(1).describe(
+    "Short progress update shown in chat (1-2 sentences). Use while researching, drafting, or waiting on external work."
+  ),
+  phase: reportStatusPhaseSchema.optional().describe(
+    "Lifecycle phase for the status marker. Defaults to running. Use succeeded or failed when a step finishes."
+  )
+});
+var reportStatusToolOutputSchema = z8.object({
+  message: z8.string().min(1),
+  phase: reportStatusPhaseSchema
+});
+function normalizeReportStatusToolInput(input) {
+  const parsed = reportStatusToolInputSchema.parse(input);
+  return {
+    message: parsed.message.trim(),
+    phase: parsed.phase
+  };
+}
+async function executeReportStatusTool(input) {
+  const normalized = normalizeReportStatusToolInput(input);
+  return {
+    message: normalized.message,
+    phase: normalized.phase ?? "running"
+  };
+}
+function buildReportStatusToolDefinition(options = {}) {
+  const description = options.description ?? 'Post a short progress update to the chat UI while you work. Call this before and during long steps (research, drafting, tool runs) so the user sees what is happening. Use phase "running" while in progress, "succeeded" or "failed" when a step completes, and "waiting" when blocked on external input.';
+  return {
+    description,
+    inputSchema: reportStatusToolInputSchema,
+    outputSchema: reportStatusToolOutputSchema,
+    execute: executeReportStatusTool
+  };
+}
+
+// src/ai/report-status-tool.ts
+function reportStatusTool(options = {}) {
+  return tool5(buildReportStatusToolDefinition(options));
+}
+
 // src/ai/format-tool-approval-task.ts
 function defaultFormatToolApprovalTask(toolCall, options = {}) {
   const approveId = options.approveActionId ?? "approve";
@@ -2063,6 +2456,56 @@ async function runWithRobotRockApprovals(options) {
   throw new Error(`RobotRock approval loop exceeded maxRounds (${maxRounds})`);
 }
 
+// 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 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");
@@ -2090,7 +2533,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);
+    }
   };
 }
 export {
@@ -2102,6 +2557,8 @@ export {
   createRobotRockToolApproval,
   createSendToHumanTool,
   createSendUpdateTool,
+  reportStatusTool,
+  requestActionInputTool,
   resolveToolApprovalsViaRobotRock,
   runWithRobotRockApprovals
 };