robotrock 0.8.1 → 0.8.3

package/dist/ai/index.js

@@ -53,13 +53,237 @@ var __callDispose = (stack, error, hasError) => {
   return next();
 };
 
-// src/schemas/index.ts
+// ../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
+var init_clsx = __esm({
+  "../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs"() {
+    "use strict";
+  }
+});
+
+// ../core/src/utils/cn.ts
+var init_cn = __esm({
+  "../core/src/utils/cn.ts"() {
+    "use strict";
+    init_clsx();
+  }
+});
+
+// ../core/src/utils/convex-sanitize.ts
+var init_convex_sanitize = __esm({
+  "../core/src/utils/convex-sanitize.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/utils/safe-url.ts
+function normalizeHostname(hostname) {
+  return hostname.toLowerCase().replace(/^\[|\]$/g, "");
+}
+function isBlockedIpv4(host) {
+  const match = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
+  if (!match) {
+    return false;
+  }
+  const octets = match.slice(1, 5).map((part) => Number(part));
+  if (octets.some((octet) => Number.isNaN(octet) || octet < 0 || octet > 255)) {
+    return true;
+  }
+  const [a, b, _c, _d] = octets;
+  if (a === void 0 || b === void 0) {
+    return true;
+  }
+  if (a === 127 || a === 0) return true;
+  if (a === 10) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  return false;
+}
+function ipv4FromNumericHost(host) {
+  if (/^\d+$/.test(host)) {
+    const num = Number(host);
+    if (!Number.isFinite(num) || num < 0 || num > 4294967295) {
+      return null;
+    }
+    const a = num >>> 24 & 255;
+    const b = num >>> 16 & 255;
+    const c = num >>> 8 & 255;
+    const d = num & 255;
+    return `${a}.${b}.${c}.${d}`;
+  }
+  const hexMatch = /^0x([0-9a-f]{1,8})$/i.exec(host);
+  if (hexMatch) {
+    const num = Number.parseInt(hexMatch[1], 16);
+    if (!Number.isFinite(num) || num < 0 || num > 4294967295) {
+      return null;
+    }
+    const a = num >>> 24 & 255;
+    const b = num >>> 16 & 255;
+    const c = num >>> 8 & 255;
+    const d = num & 255;
+    return `${a}.${b}.${c}.${d}`;
+  }
+  return null;
+}
+function isBlockedIpv4Mapped(host) {
+  const mappedDotted = /^::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/i.exec(host);
+  if (mappedDotted) {
+    return isBlockedIpv4(mappedDotted[1]);
+  }
+  const mappedHex = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i.exec(host);
+  if (mappedHex) {
+    const high = Number.parseInt(mappedHex[1], 16);
+    const low = Number.parseInt(mappedHex[2], 16);
+    if (Number.isFinite(high) && Number.isFinite(low)) {
+      const a = high >> 8 & 255;
+      const b = high & 255;
+      const c = low >> 8 & 255;
+      const d = low & 255;
+      return isBlockedIpv4(`${a}.${b}.${c}.${d}`);
+    }
+  }
+  return false;
+}
+function isBlockedIpv6(host) {
+  if (host === "::1" || host === "0:0:0:0:0:0:0:1") {
+    return true;
+  }
+  if (host.startsWith("fc") || host.startsWith("fd")) {
+    return true;
+  }
+  if (host.startsWith("fe80:")) {
+    return true;
+  }
+  if (isBlockedIpv4Mapped(host)) {
+    return true;
+  }
+  return false;
+}
+function isBlockedHostname(hostname) {
+  const host = normalizeHostname(hostname);
+  if (!host) {
+    return true;
+  }
+  if (BLOCKED_HOSTNAMES.has(host)) {
+    return true;
+  }
+  if (host.endsWith(".localhost") || host.endsWith(".local")) {
+    return true;
+  }
+  const numericIpv4 = ipv4FromNumericHost(host);
+  if (numericIpv4 && isBlockedIpv4(numericIpv4)) {
+    return true;
+  }
+  return isBlockedIpv4(host) || isBlockedIpv6(host);
+}
+function isPublicHttpUrl(urlString) {
+  let url;
+  try {
+    url = new URL(urlString);
+  } catch {
+    return false;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    return false;
+  }
+  if (url.username || url.password) {
+    return false;
+  }
+  return !isBlockedHostname(url.hostname);
+}
+var BLOCKED_HOSTNAMES, PUBLIC_HTTP_URL_ERROR;
+var init_safe_url = __esm({
+  "../core/src/utils/safe-url.ts"() {
+    "use strict";
+    BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set([
+      "localhost",
+      "metadata.google.internal",
+      "metadata.goog"
+    ]);
+    PUBLIC_HTTP_URL_ERROR = "URL must be a public http:// or https:// address";
+  }
+});
+
+// ../core/src/utils/task-app.ts
+var init_task_app = __esm({
+  "../core/src/utils/task-app.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/utils/index.ts
+var init_utils = __esm({
+  "../core/src/utils/index.ts"() {
+    "use strict";
+    init_cn();
+    init_convex_sanitize();
+    init_safe_url();
+    init_task_app();
+  }
+});
+
+// ../core/src/schemas/context-urls.ts
+function resolveLinkUrl(value) {
+  return value.startsWith("http://") || value.startsWith("https://") ? value : `https://${value}`;
+}
+function widgetType(ui, field) {
+  const fieldUi = ui?.[field];
+  if (typeof fieldUi !== "object" || fieldUi === null) {
+    return void 0;
+  }
+  const widget = fieldUi["ui:widget"];
+  return typeof widget === "string" ? widget : void 0;
+}
+function validateUrlValue(value, widget) {
+  if (widget === "image" || widget === "link") {
+    if (typeof value !== "string") {
+      return PUBLIC_HTTP_URL_ERROR;
+    }
+    const url = widget === "link" ? resolveLinkUrl(value) : value;
+    if (!isPublicHttpUrl(url)) {
+      return PUBLIC_HTTP_URL_ERROR;
+    }
+    return null;
+  }
+  if (widget === "attachments" && Array.isArray(value)) {
+    for (const item of value) {
+      if (typeof item !== "object" || item === null) {
+        continue;
+      }
+      const url = item.url;
+      if (typeof url === "string" && !isPublicHttpUrl(resolveLinkUrl(url))) {
+        return PUBLIC_HTTP_URL_ERROR;
+      }
+    }
+  }
+  return null;
+}
+function validateContextPublicUrls(context) {
+  if (!context?.data) {
+    return null;
+  }
+  for (const [field, value] of Object.entries(context.data)) {
+    const widget = widgetType(context.ui, field);
+    if (!widget) {
+      continue;
+    }
+    const error = validateUrlValue(value, widget);
+    if (error) {
+      return `context.data.${field}: ${error}`;
+    }
+  }
+  return null;
+}
+var init_context_urls = __esm({
+  "../core/src/schemas/context-urls.ts"() {
+    "use strict";
+    init_safe_url();
+  }
+});
+
+// ../core/src/schemas/task.ts
 import { z } from "zod";
-import {
-  isPublicHttpUrl,
-  PUBLIC_HTTP_URL_ERROR
-} from "@robotrock/core/utils";
-import { validateContextPublicUrls } from "@robotrock/core/schemas";
 function refineContextPublicUrls(data, ctx) {
   const error = validateContextPublicUrls(data.context);
   if (error) {
@@ -70,10 +294,12 @@ 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, agentTelemetrySchema, createTaskBodySchema, threadUpdateBodySchema;
-var init_schemas = __esm({
-  "src/schemas/index.ts"() {
+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, agentToolCallsSchema, agentTelemetrySchema, createTaskBodySchema;
+var init_task = __esm({
+  "../core/src/schemas/task.ts"() {
     "use strict";
+    init_safe_url();
+    init_context_urls();
     safeUrlSchema = z.string().refine((url) => isPublicHttpUrl(url), {
       message: PUBLIC_HTTP_URL_ERROR
     });
@@ -101,6 +327,7 @@ var init_schemas = __esm({
       schema: jsonSchema7Schema.optional(),
       ui: uiSchemaSchema.optional(),
       data: z.record(z.string(), z.unknown()).optional(),
+      // Optional handlers for this action - if present, must have at least 1
       handlers: z.array(handlerSchema).min(1).optional()
     });
     uiFieldSchemaSchema = z.object({
@@ -116,6 +343,7 @@ var init_schemas = __esm({
       ui: contextUiSchema
     }).optional();
     taskContextObjectSchema = z.object({
+      /** Source application id; omitted tasks are grouped in the default inbox. */
       app: z.string().min(1).optional(),
       type: z.string().min(1),
       name: z.string().min(1),
@@ -170,10 +398,17 @@ var init_schemas = __esm({
       usd: z.number().nonnegative().optional()
     });
     AGENT_INFO_MAX_KEYS = 32;
+    AGENT_TOOL_CALLS_MAX_KEYS = 64;
+    agentToolCallsSchema = z.record(z.string().min(1), nonNegativeInt);
     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()
     }).refine(
       (data) => {
@@ -181,6 +416,14 @@ var init_schemas = __esm({
         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({
       assignTo: assignToSchema.optional(),
@@ -199,9 +442,186 @@ var init_schemas = __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: agentTelemetrySchema.optional()
     }).superRefine(refineContextPublicUrls);
-    threadUpdateBodySchema = threadUpdateInputSchema;
+  }
+});
+
+// ../core/src/schemas/json-schema.ts
+var init_json_schema = __esm({
+  "../core/src/schemas/json-schema.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/schemas/index.ts
+var init_schemas = __esm({
+  "../core/src/schemas/index.ts"() {
+    "use strict";
+    init_task();
+    init_json_schema();
+    init_context_urls();
+  }
+});
+
+// src/schemas/index.ts
+import { z as z2 } from "zod";
+function refineContextPublicUrls2(data, ctx) {
+  const error = validateContextPublicUrls(data.context);
+  if (error) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: error,
+      path: ["context"]
+    });
+  }
+}
+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, agentToolCallsSchema2, agentTelemetrySchema2, createTaskBodySchema2, threadUpdateBodySchema;
+var init_schemas2 = __esm({
+  "src/schemas/index.ts"() {
+    "use strict";
+    init_utils();
+    init_schemas();
+    safeUrlSchema2 = z2.string().refine((url) => isPublicHttpUrl(url), {
+      message: PUBLIC_HTTP_URL_ERROR
+    });
+    jsonSchema7Schema2 = z2.custom(
+      (val) => typeof val === "object" && val !== null,
+      { message: "Must be a valid JSON Schema object" }
+    );
+    uiSchemaSchema2 = z2.custom((val) => typeof val === "object" && val !== null, {
+      message: "Must be a valid UiSchema object"
+    });
+    webhookHandlerSchema2 = z2.object({
+      type: z2.literal("webhook"),
+      url: safeUrlSchema2,
+      headers: z2.record(z2.string(), z2.string())
+    });
+    triggerHandlerSchema2 = webhookHandlerSchema2.extend({
+      type: z2.literal("trigger"),
+      tokenId: z2.string().min(1)
+    });
+    handlerSchema2 = z2.discriminatedUnion("type", [webhookHandlerSchema2, triggerHandlerSchema2]);
+    taskActionSchema2 = 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(),
+      handlers: z2.array(handlerSchema2).min(1).optional()
+    });
+    uiFieldSchemaSchema2 = z2.object({
+      "ui:widget": z2.string().optional(),
+      "ui:title": z2.string().optional(),
+      "ui:description": z2.string().optional(),
+      "ui:options": z2.record(z2.string(), z2.unknown()).optional(),
+      items: z2.lazy(() => z2.record(z2.string(), uiFieldSchemaSchema2)).optional()
+    }).passthrough();
+    contextUiSchema2 = z2.record(z2.string(), uiFieldSchemaSchema2).optional();
+    contextDataSchema2 = z2.object({
+      data: z2.record(z2.string(), z2.unknown()),
+      ui: contextUiSchema2
+    }).optional();
+    taskContextObjectSchema2 = 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,
+      version: z2.literal(2).optional(),
+      actions: z2.array(taskActionSchema2).min(1, "At least one action is required")
+    });
+    taskContextSchema2 = taskContextObjectSchema2.superRefine(
+      refineContextPublicUrls2
+    );
+    assignToSchema2 = z2.object({
+      users: z2.array(z2.string().email()).optional(),
+      groups: z2.array(z2.string().min(1)).optional()
+    }).refine(
+      (data) => {
+        const groups = data.groups ?? [];
+        if (groups.includes("all") && groups.length > 1) {
+          return false;
+        }
+        return true;
+      },
+      { message: 'Cannot combine "all" with other group slugs' }
+    );
+    threadUpdateMessageSchema2 = z2.string().min(1).max(500);
+    threadUpdateStatuses2 = [
+      "info",
+      "queued",
+      "running",
+      "waiting",
+      "succeeded",
+      "failed",
+      "cancelled"
+    ];
+    threadUpdateStatusSchema2 = z2.enum(threadUpdateStatuses2);
+    threadUpdateInputSchema2 = z2.object({
+      message: threadUpdateMessageSchema2,
+      status: threadUpdateStatusSchema2.optional()
+    });
+    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;
+    agentToolCallsSchema2 = z2.record(z2.string().min(1), nonNegativeInt2);
+    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()
+    }).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({
+      assignTo: assignToSchema2.optional(),
+      /**
+       * Groups related tasks together. When omitted, the server generates one and
+       * returns it so the caller can reuse it on later tasks in the same thread.
+       */
+      threadId: z2.string().min(1).optional(),
+      /**
+       * Optional thread priority. When set, applies to the whole thread and
+       * overwrites any previous priority. Omit on later tasks to leave unchanged.
+       */
+      priority: taskPrioritySchema2.optional(),
+      /**
+       * Optional initial status update logged against the task's thread. Shows in
+       * the inbox status bar and the thread update log.
+       */
+      update: threadUpdateInputSchema2.optional(),
+      agent: agentTelemetrySchema2.optional()
+    }).superRefine(refineContextPublicUrls2);
+    threadUpdateBodySchema = threadUpdateInputSchema2;
   }
 });
 
@@ -346,7 +766,7 @@ var DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS, RobotRockError, RobotRock;
 var init_client = __esm({
   "src/client.ts"() {
     "use strict";
-    init_schemas();
+    init_schemas2();
     init_approval_result();
     DEFAULT_POLL_INTERVAL_MS = 2e3;
     DEFAULT_TIMEOUT_MS = 24 * 60 * 60 * 1e3;
@@ -402,7 +822,7 @@ var init_client = __esm({
           ...task2.update !== void 0 ? { update: task2.update } : {},
           ...task2.agent !== void 0 ? { agent: task2.agent } : {}
         };
-        const validation = createTaskBodySchema.safeParse(bodyPayload);
+        const validation = createTaskBodySchema2.safeParse(bodyPayload);
         if (!validation.success) {
           throw new RobotRockError(
             `Invalid task: ${validation.error.issues[0]?.message}`,
@@ -845,7 +1265,7 @@ var init_workflow = __esm({
 import { tool } from "ai";
 
 // src/ai/approve-by-human-tool-core.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/ai/context.ts
 init_client();
@@ -989,11 +1409,11 @@ var APPROVE_BY_HUMAN_ACTIONS4 = [
   { id: "approve", title: "Approve" },
   { id: "decline", title: "Decline" }
 ];
-var approveByHumanInputSchema = z2.object({
-  type: z2.string().optional().describe("Task type slug; defaults to ai-approval"),
-  name: z2.string().describe("Short title for the approval request"),
-  description: z2.string().describe("What needs approval and the consequences of approving or declining"),
-  contextSummary: z2.string().optional().describe("Optional markdown summary shown to the reviewer")
+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")
 });
 function resolveApproveByHumanToolConfig(clientOrContext, maybeOptions = {}) {
   const isDurable = typeof clientOrContext === "object" && clientOrContext !== null && "mode" in clientOrContext && (clientOrContext.mode === "trigger" || clientOrContext.mode === "workflow");
@@ -1042,18 +1462,18 @@ function approveByHumanTool(clientOrContext, maybeOptions = {}) {
 import { tool as tool2 } from "ai";
 
 // src/ai/create-send-to-human-tool-core.ts
-init_schemas();
-import { z as z3 } from "zod";
-var sendToHumanToolInputSchema = z3.object({
-  type: z3.string().describe("Task type slug shown in the RobotRock inbox"),
-  name: z3.string().describe("Short title for the human reviewer"),
-  description: z3.string().optional().describe("What you need from the human and why you cannot proceed alone"),
-  context: z3.object({
-    data: z3.record(z3.string(), z3.unknown()).optional(),
-    ui: z3.record(z3.string(), z3.unknown()).optional()
+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()
   }).optional().describe("Optional structured context for the inbox UI"),
-  validUntil: z3.string().datetime().optional().describe("Optional ISO deadline for the task"),
-  assignTo: assignToSchema.optional().describe(
+  validUntil: z4.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"
   )
 });
@@ -1104,15 +1524,15 @@ function createSendToHumanTool(clientOrOptions, maybeOptions) {
 import { tool as tool3 } from "ai";
 
 // src/ai/create-send-update-tool-core.ts
-init_schemas();
+init_schemas2();
 init_client();
-import { z as z4 } from "zod";
-var sendUpdateToolInputSchema = z4.object({
-  threadId: z4.string().optional().describe(
+import { z as z5 } from "zod";
+var sendUpdateToolInputSchema = z5.object({
+  threadId: z5.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: z4.string().describe("Short progress update (1-2 sentences) shown in the inbox status bar"),
-  status: threadUpdateStatusSchema.optional().describe(
+  message: z5.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"
   )
 });