robotrock 1.0.0 → 1.3.0

package/dist/eve/tools/index.js

@@ -0,0 +1,2848 @@
+// src/eve/tools/inbox/create-task.ts
+import { defineTool } from "eve/tools";
+import { z as z6 } from "zod";
+
+// src/schemas/index.ts
+import { z as z4 } from "zod";
+
+// ../core/src/utils/safe-url.ts
+var BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set([
+  "localhost",
+  "metadata.google.internal",
+  "metadata.goog"
+]);
+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 isLoopbackHandlerUrl(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;
+  }
+  const host = url.hostname.toLowerCase();
+  return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]" || host.endsWith(".localhost");
+}
+function isAllowedHandlerUrl(urlString) {
+  return isPublicHttpUrl(urlString) || isLoopbackHandlerUrl(urlString);
+}
+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 PUBLIC_HTTP_URL_ERROR = "URL must be a public http:// or https:// address";
+var HANDLER_URL_ERROR = "Handler URL must be a public or loopback http:// or https:// address";
+
+// ../core/src/schemas/task.ts
+import { z } from "zod";
+
+// ../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;
+}
+
+// ../core/src/schemas/task.ts
+var safeUrlSchema = z.string().refine((url) => isPublicHttpUrl(url), {
+  message: PUBLIC_HTTP_URL_ERROR
+});
+var handlerUrlSchema = z.string().refine((url) => isAllowedHandlerUrl(url), {
+  message: HANDLER_URL_ERROR
+});
+var jsonSchema7Schema = z.custom(
+  (val) => typeof val === "object" && val !== null,
+  { message: "Must be a valid JSON Schema object" }
+);
+var uiSchemaSchema = z.custom((val) => typeof val === "object" && val !== null, {
+  message: "Must be a valid UiSchema object"
+});
+var webhookHandlerSchema = z.object({
+  type: z.literal("webhook"),
+  url: handlerUrlSchema,
+  headers: z.record(z.string(), z.string())
+});
+var triggerHandlerSchema = webhookHandlerSchema.extend({
+  type: z.literal("trigger"),
+  tokenId: z.string().min(1)
+});
+var handlerSchema = z.discriminatedUnion("type", [webhookHandlerSchema, triggerHandlerSchema]);
+var taskActionInputSchema = z.object({
+  id: z.string().min(1),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  schema: jsonSchema7Schema.optional(),
+  ui: uiSchemaSchema.optional(),
+  data: z.record(z.string(), z.unknown()).optional()
+});
+var taskActionSchema = taskActionInputSchema.extend({
+  // Optional handlers for this action - if present, must have at least 1
+  handlers: z.array(handlerSchema).min(1).optional()
+});
+var uiFieldSchemaSchema = z.object({
+  "ui:widget": z.string().optional(),
+  "ui:title": z.string().optional(),
+  "ui:description": z.string().optional(),
+  "ui:options": z.record(z.string(), z.unknown()).optional(),
+  items: z.lazy(() => z.record(z.string(), uiFieldSchemaSchema)).optional()
+}).passthrough();
+var contextUiSchema = z.record(z.string(), uiFieldSchemaSchema).optional();
+var contextDataSchema = z.object({
+  data: z.record(z.string(), z.unknown()),
+  ui: contextUiSchema
+}).optional();
+var TASK_CONTEXT_FORMAT_VERSION = 2;
+var taskContextObjectBaseSchema = z.object({
+  /** Source application id; omitted tasks are grouped in the default inbox. */
+  app: z.string().min(1).optional(),
+  type: z.string().min(1),
+  name: z.string().min(1),
+  description: z.string().optional(),
+  validUntil: z.string().optional(),
+  context: contextDataSchema,
+  /** Task context wire format version. @default 2 */
+  contextVersion: z.literal(2).optional(),
+  /** @deprecated Use `contextVersion`. Accepted on ingest only. */
+  version: z.literal(2).optional(),
+  actions: z.array(taskActionSchema).min(1, "At least one action is required")
+});
+function normalizeTaskContextVersion(data) {
+  const { version: legacyVersion, contextVersion, ...rest } = data;
+  return {
+    ...rest,
+    contextVersion: contextVersion ?? legacyVersion ?? TASK_CONTEXT_FORMAT_VERSION
+  };
+}
+var taskContextObjectSchema = taskContextObjectBaseSchema.transform(
+  normalizeTaskContextVersion
+);
+function refineContextPublicUrls(data, ctx) {
+  const error = validateContextPublicUrls(data.context);
+  if (error) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: error,
+      path: ["context"]
+    });
+  }
+}
+var taskContextSchema = taskContextObjectSchema.superRefine(
+  refineContextPublicUrls
+);
+var assignToSchema = z.object({
+  users: z.array(z.string().email()).optional(),
+  groups: z.array(z.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' }
+);
+var threadUpdateMessageSchema = z.string().min(1).max(500);
+var threadUpdateStatuses = [
+  "info",
+  "queued",
+  "running",
+  "waiting",
+  "succeeded",
+  "failed",
+  "cancelled"
+];
+var threadUpdateStatusSchema = z.enum(threadUpdateStatuses);
+var threadUpdateInputSchema = z.object({
+  message: threadUpdateMessageSchema,
+  status: threadUpdateStatusSchema.optional()
+});
+var taskPriorities = ["low", "normal", "high", "urgent"];
+var taskPrioritySchema = z.enum(taskPriorities);
+var agentTelemetrySchema = z.object({
+  /** Agent or app version (semver, git SHA, deploy tag — caller-defined). */
+  version: z.string().min(1)
+});
+var createTaskBodySchema = taskContextObjectBaseSchema.extend({
+  assignTo: assignToSchema.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: z.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: taskPrioritySchema.optional(),
+  /**
+   * Optional initial status update logged against the task's thread. Shows in
+   * the inbox status bar and the thread update log.
+   */
+  update: threadUpdateInputSchema.optional(),
+  /** Agent release version — not shown in inbox UI. */
+  agent: agentTelemetrySchema.optional()
+}).transform(normalizeTaskContextVersion).superRefine(refineContextPublicUrls);
+var agentChatSeedActionSchema = z.object({
+  /** Stable action id echoed back on submit; auto-derived from title when omitted. */
+  id: z.string().min(1).optional(),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  /** JSON Schema object for the form fields. */
+  schema: z.record(z.string(), z.unknown()).optional(),
+  /** RJSF ui schema overrides (ui:widget, ui:enumNames, etc.). */
+  ui: z.record(z.string(), z.unknown()).optional(),
+  /** Optional default field values. */
+  data: z.record(z.string(), z.unknown()).optional()
+});
+var agentChatSeedMessageSchema = z.object({
+  role: z.enum(["user", "assistant"]),
+  text: z.string().min(1),
+  /** Optional display-name override for the message sender. */
+  senderName: z.string().min(1).optional(),
+  /**
+   * Optional structured input request rendered as a styled RobotRock action
+   * widget below the message text. Use this instead of asking the user to reply
+   * in plain text so the request is always a proper action form.
+   */
+  requestActionInput: z.object({
+    prompt: z.string().optional(),
+    action: agentChatSeedActionSchema
+  }).optional()
+});
+var eveAgentChatTransportSchema = z.object({
+  kind: z.literal("eve"),
+  chatId: z.string().min(1),
+  baseUrl: z.string().url(),
+  sessionId: z.string().optional(),
+  continuationToken: z.string().optional(),
+  streamIndex: z.number().int().nonnegative().optional(),
+  isStreaming: z.boolean().optional()
+});
+var createAgentChatBodySchema = z.object({
+  /** Agent id (eve agent name). 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 tenantEveConnections id; resolved from the tenant when omitted. */
+  eveConnectionId: z.string().min(1).optional(),
+  /** Source application id; groups the chat under an inbox section. */
+  app: z.string().min(1).optional(),
+  /** Email of the user who owns the chat. Required unless `parentChatId` is set. */
+  ownerEmail: z.string().email().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"
+}).refine((data) => Boolean(data.ownerEmail || data.parentChatId), {
+  message: "Provide ownerEmail unless parentChatId is set"
+});
+var agentChatAuditToolBodySchema = z.object({
+  eveSessionId: z.string().min(1),
+  userId: z.string().min(1),
+  toolCallId: z.string().min(1),
+  toolName: z.string().min(1),
+  input: z.record(z.string(), z.unknown()).default({}),
+  success: z.boolean(),
+  status: z.enum(["completed", "failed", "rejected"]),
+  error: z.string().optional(),
+  idempotencyKey: z.string().optional()
+});
+var agentChatAuditInputBodySchema = z.object({
+  eveSessionId: z.string().min(1),
+  userId: z.string().min(1),
+  actionId: z.string().min(1),
+  actionTitle: z.string().optional(),
+  prompt: z.string().optional(),
+  data: z.record(z.string(), z.unknown()).optional(),
+  idempotencyKey: z.string().optional(),
+  /** Eve input request id — used to merge staged HITL metadata. */
+  requestId: z.string().optional(),
+  /** Eve tool call id — fallback lookup for staged HITL metadata. */
+  toolCallId: z.string().optional()
+});
+var eveHitlStagedOptionSchema = z.object({
+  id: z.string(),
+  label: z.string()
+});
+var agentChatStageHitlBodySchema = z.object({
+  eveSessionId: z.string().min(1),
+  requests: z.array(
+    z.object({
+      requestId: z.string().min(1),
+      toolCallId: z.string().min(1),
+      toolName: z.string().min(1),
+      prompt: z.string().min(1),
+      display: z.enum(["confirmation", "select", "text"]).optional(),
+      allowFreeform: z.boolean().optional(),
+      options: z.array(eveHitlStagedOptionSchema).optional(),
+      toolInput: z.record(z.string(), z.unknown()).optional()
+    })
+  )
+});
+var agentChatLinkTaskBodySchema = z.object({
+  eveSessionId: z.string().min(1),
+  publicTaskId: z.string().min(1),
+  toolCallId: z.string().min(1)
+});
+
+// ../core/src/schemas/tool-result-display.ts
+import { z as z2 } from "zod";
+var toolDisplayMetadataSchema = z2.object({
+  widget: z2.string().optional(),
+  title: z2.string().optional(),
+  description: z2.string().optional()
+});
+var toolDisplayEnvelopeSchema = z2.object({
+  display: toolDisplayMetadataSchema.optional(),
+  data: z2.record(z2.string(), z2.unknown()),
+  ui: z2.record(
+    z2.string(),
+    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()
+    }).passthrough()
+  ).optional()
+});
+
+// ../core/src/schemas/agent-admin.ts
+import { z as z3 } from "zod";
+var tenantRoleSchema = z3.enum(["admin", "member"]);
+var agentAdminUserSchema = z3.object({
+  id: z3.string(),
+  email: z3.string().email(),
+  name: z3.string()
+});
+var agentAdminMemberSchema = z3.object({
+  userId: z3.string(),
+  role: z3.string(),
+  membershipKind: z3.enum(["team", "assignee"]),
+  hasLoggedIn: z3.boolean(),
+  user: agentAdminUserSchema
+});
+var agentAdminGroupSchema = z3.object({
+  id: z3.string(),
+  name: z3.string(),
+  slug: z3.string(),
+  description: z3.string().nullable(),
+  memberCount: z3.number().optional()
+});
+var agentAdminGroupDetailSchema = agentAdminGroupSchema.extend({
+  members: z3.array(
+    z3.object({
+      userId: z3.string(),
+      user: agentAdminUserSchema
+    })
+  )
+});
+var agentAdminTaskSummarySchema = z3.object({
+  id: z3.string(),
+  convexId: z3.string(),
+  status: z3.string(),
+  type: z3.string().nullable(),
+  name: z3.string().nullable(),
+  description: z3.string().nullable(),
+  validUntil: z3.number(),
+  createdAt: z3.number(),
+  threadPriority: z3.string().nullable(),
+  handledByUserId: z3.string().nullable()
+});
+var inviteMemberBodySchema = z3.object({
+  email: z3.string().email(),
+  role: tenantRoleSchema.optional()
+});
+var updateMemberRoleBodySchema = z3.object({
+  role: tenantRoleSchema
+});
+var createGroupBodySchema = z3.object({
+  name: z3.string().min(1),
+  description: z3.string().optional()
+});
+var updateGroupBodySchema = z3.object({
+  name: z3.string().min(1).optional(),
+  description: z3.string().optional()
+});
+var addGroupMemberBodySchema = z3.object({
+  userId: z3.string().min(1).describe("Convex user id or member email.")
+});
+var listTasksQuerySchema = z3.object({
+  statusFilter: z3.enum(["all", "open", "handled", "expired"]).optional(),
+  typeFilter: z3.string().optional(),
+  appFilter: z3.string().optional(),
+  sortField: z3.enum(["type", "date", "status", "validUntil"]).optional(),
+  sortDirection: z3.enum(["asc", "desc"]).optional(),
+  limit: z3.coerce.number().int().positive().max(100).optional(),
+  cursor: z3.string().optional()
+});
+var searchTasksQuerySchema = z3.object({
+  q: z3.string().min(1),
+  limit: z3.coerce.number().int().positive().max(100).optional()
+});
+var assignTasksResultSchema = z3.object({
+  taskId: z3.string(),
+  success: z3.boolean(),
+  message: z3.string().optional(),
+  name: z3.string().nullable().optional(),
+  description: z3.string().nullable().optional(),
+  type: z3.string().nullable().optional()
+});
+var assignTasksResponseSchema = z3.object({
+  results: z3.array(assignTasksResultSchema)
+});
+var assignTasksBodySchema = z3.object({
+  taskIds: z3.array(z3.string().min(1)).min(1).max(100),
+  assignTo: assignToSchema.refine(
+    (value) => (value.users?.length ?? 0) > 0 || (value.groups?.length ?? 0) > 0,
+    { message: "assignTo needs at least one user email or group slug." }
+  )
+});
+
+// src/schemas/index.ts
+var handlerUrlSchema2 = z4.string().refine((url) => isAllowedHandlerUrl(url), {
+  message: HANDLER_URL_ERROR
+});
+var jsonSchema7Schema2 = z4.custom(
+  (val) => typeof val === "object" && val !== null,
+  { message: "Must be a valid JSON Schema object" }
+);
+var uiSchemaSchema2 = z4.custom((val) => typeof val === "object" && val !== null, {
+  message: "Must be a valid UiSchema object"
+});
+var webhookHandlerSchema2 = z4.object({
+  type: z4.literal("webhook"),
+  url: handlerUrlSchema2,
+  headers: z4.record(z4.string(), z4.string())
+});
+var triggerHandlerSchema2 = webhookHandlerSchema2.extend({
+  type: z4.literal("trigger"),
+  tokenId: z4.string().min(1)
+});
+var handlerSchema2 = z4.discriminatedUnion("type", [webhookHandlerSchema2, triggerHandlerSchema2]);
+var taskActionInputSchema2 = z4.object({
+  id: z4.string().min(1),
+  title: z4.string().min(1),
+  description: z4.string().optional(),
+  schema: jsonSchema7Schema2.optional(),
+  ui: uiSchemaSchema2.optional(),
+  data: z4.record(z4.string(), z4.unknown()).optional()
+});
+var taskActionSchema2 = taskActionInputSchema2.extend({
+  handlers: z4.array(handlerSchema2).min(1).optional()
+});
+var uiFieldSchemaSchema2 = z4.object({
+  "ui:widget": z4.string().optional(),
+  "ui:title": z4.string().optional(),
+  "ui:description": z4.string().optional(),
+  "ui:options": z4.record(z4.string(), z4.unknown()).optional(),
+  items: z4.lazy(() => z4.record(z4.string(), uiFieldSchemaSchema2)).optional()
+}).passthrough();
+var contextUiSchema2 = z4.record(z4.string(), uiFieldSchemaSchema2).optional();
+var contextDataSchema2 = z4.object({
+  data: z4.record(z4.string(), z4.unknown()),
+  ui: contextUiSchema2
+}).optional();
+var TASK_CONTEXT_FORMAT_VERSION2 = 2;
+var taskContextObjectBaseSchema2 = z4.object({
+  app: z4.string().min(1).optional(),
+  type: z4.string().min(1),
+  name: z4.string().min(1),
+  description: z4.string().optional(),
+  validUntil: z4.string().optional(),
+  context: contextDataSchema2,
+  contextVersion: z4.literal(2).optional(),
+  /** @deprecated Use `contextVersion`. Accepted on ingest only. */
+  version: z4.literal(2).optional(),
+  actions: z4.array(taskActionSchema2).min(1, "At least one action is required")
+});
+function normalizeTaskContextVersion2(data) {
+  const { version: legacyVersion, contextVersion, ...rest } = data;
+  return {
+    ...rest,
+    contextVersion: contextVersion ?? legacyVersion ?? TASK_CONTEXT_FORMAT_VERSION2
+  };
+}
+var taskContextObjectSchema2 = taskContextObjectBaseSchema2.transform(
+  normalizeTaskContextVersion2
+);
+function refineContextPublicUrls2(data, ctx) {
+  const error = validateContextPublicUrls(data.context);
+  if (error) {
+    ctx.addIssue({
+      code: z4.ZodIssueCode.custom,
+      message: error,
+      path: ["context"]
+    });
+  }
+}
+var taskContextSchema2 = taskContextObjectSchema2.superRefine(
+  refineContextPublicUrls2
+);
+var assignToSchema2 = z4.object({
+  users: z4.array(z4.string().email()).optional(),
+  groups: z4.array(z4.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' }
+);
+var threadUpdateMessageSchema2 = z4.string().min(1).max(500);
+var threadUpdateStatuses2 = [
+  "info",
+  "queued",
+  "running",
+  "waiting",
+  "succeeded",
+  "failed",
+  "cancelled"
+];
+var threadUpdateStatusSchema2 = z4.enum(threadUpdateStatuses2);
+var threadUpdateInputSchema2 = z4.object({
+  message: threadUpdateMessageSchema2,
+  status: threadUpdateStatusSchema2.optional()
+});
+var taskPriorities2 = ["low", "normal", "high", "urgent"];
+var taskPrioritySchema2 = z4.enum(taskPriorities2);
+var agentTelemetrySchema2 = z4.object({
+  version: z4.string().min(1)
+});
+var createTaskBodySchema2 = taskContextObjectBaseSchema2.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: z4.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()
+}).transform(normalizeTaskContextVersion2).superRefine(refineContextPublicUrls2);
+var threadUpdateBodySchema = threadUpdateInputSchema2;
+
+// ../core/src/handler-retry.ts
+var HANDLER_RETRY_DELAYS_MS = [
+  6e4,
+  // 1m
+  3e5,
+  // 5m
+  18e5,
+  // 30m
+  36e5,
+  // 1h
+  216e5,
+  // 6h
+  864e5,
+  // 24h
+  1728e5
+  // 48h
+];
+var HANDLER_MAX_ATTEMPTS = HANDLER_RETRY_DELAYS_MS.length + 1;
+
+// ../core/src/attribution/index.ts
+import { z as z5 } from "zod";
+
+// ../core/src/app-url.ts
+var PRODUCTION_APP_URL = "https://app.robotrock.io";
+var PRODUCTION_API_URL = "https://api.robotrock.io/v1";
+var DEV_API_URL = "http://localhost:4001/v1";
+var APP_SIGNUP_URL = `${PRODUCTION_APP_URL}/sign-up`;
+function normalizeRobotRockApiBaseUrl(baseUrl) {
+  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  if (trimmed.endsWith("/v1")) {
+    return trimmed;
+  }
+  return `${trimmed}/v1`;
+}
+function getRobotRockApiBaseUrl() {
+  const explicit = process.env.ROBOTROCK_BASE_URL?.trim() || process.env.ROBOTROCK_API_URL?.trim();
+  if (explicit) {
+    return normalizeRobotRockApiBaseUrl(explicit);
+  }
+  if (process.env.NODE_ENV === "production") {
+    return PRODUCTION_API_URL;
+  }
+  return DEV_API_URL;
+}
+
+// ../core/src/attribution/index.ts
+var ATTRIBUTION_COOKIE_MAX_AGE = 60 * 60 * 24 * 90;
+var attributionSchema = z5.object({
+  utmSource: z5.string().optional(),
+  utmMedium: z5.string().optional(),
+  utmCampaign: z5.string().optional(),
+  utmContent: z5.string().optional(),
+  utmTerm: z5.string().optional(),
+  gclid: z5.string().optional(),
+  landingUrl: z5.string().optional(),
+  referrer: z5.string().optional(),
+  capturedAt: z5.number()
+});
+
+// src/approval-result.ts
+var TaskTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TaskTimeoutError";
+  }
+};
+var TaskExpiredError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TaskExpiredError";
+  }
+};
+function toDiscriminatedApprovalResult(actions, task) {
+  void actions;
+  if (!task.handled) {
+    throw new Error("Task has no handled result");
+  }
+  return {
+    actionId: task.handled.action.id,
+    data: task.handled.action.data,
+    handledBy: task.handled.handledBy,
+    handledAt: new Date(task.handledAt ?? Date.now()),
+    taskId: task.id
+  };
+}
+
+// src/http.ts
+var RobotRockError = class extends Error {
+  constructor(message, statusCode, response) {
+    super(message);
+    this.statusCode = statusCode;
+    this.response = response;
+    this.name = "RobotRockError";
+  }
+};
+async function parseResponseBody(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  const bodyText = await response.text();
+  if (!bodyText) {
+    return null;
+  }
+  if (contentType.toLowerCase().includes("application/json")) {
+    try {
+      return JSON.parse(bodyText);
+    } catch {
+    }
+  }
+  try {
+    return JSON.parse(bodyText);
+  } catch {
+    return bodyText;
+  }
+}
+function getErrorMessage(data, fallback) {
+  if (data && typeof data === "object" && !Array.isArray(data)) {
+    const record = data;
+    const maybeMessage = record.message;
+    const maybeHint = record.hint;
+    if (typeof maybeMessage === "string" && maybeMessage.trim()) {
+      if (typeof maybeHint === "string" && maybeHint.trim()) {
+        return `${maybeMessage.trim()} ${maybeHint.trim()}`;
+      }
+      return maybeMessage;
+    }
+  }
+  if (typeof data === "string" && data.trim()) {
+    const compact = data.replace(/\s+/g, " ").trim();
+    const snippet = compact.length > 180 ? `${compact.slice(0, 180)}...` : compact;
+    return `${fallback}. Server returned non-JSON response: ${snippet}`;
+  }
+  return fallback;
+}
+
+// src/auth-headers.ts
+var ROBOTROCK_ACTING_USER_ID_HEADER = "x-robotrock-acting-user-id";
+function buildRobotRockAuthHeaders(auth) {
+  if (auth.kind === "apiKey") {
+    const headers2 = {
+      "X-Api-Key": auth.apiKey
+    };
+    if (auth.actingUserId?.trim()) {
+      headers2[ROBOTROCK_ACTING_USER_ID_HEADER] = auth.actingUserId.trim();
+    }
+    return headers2;
+  }
+  const headers = {
+    Authorization: `Bearer ${auth.token}`,
+    "X-RobotRock-Tenant-Slug": auth.tenantSlug,
+    "X-RobotRock-Connection-Id": auth.connectionId
+  };
+  if (auth.actingUserId?.trim()) {
+    headers[ROBOTROCK_ACTING_USER_ID_HEADER] = auth.actingUserId.trim();
+  }
+  return headers;
+}
+function resolveRobotRockAuthConfig(overrides) {
+  if (overrides?.agentService) {
+    return {
+      kind: "agentService",
+      ...overrides.agentService
+    };
+  }
+  const apiKey = overrides?.apiKey ?? process.env.ROBOTROCK_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "RobotRock auth is required. Set ROBOTROCK_API_KEY, ROBOTROCK_AGENT_SERVICE_TOKEN with tenant context, or pass auth when creating the client."
+    );
+  }
+  return { kind: "apiKey", apiKey };
+}
+
+// src/chats.ts
+function createChatsApi(config) {
+  const headers = () => ({
+    "Content-Type": "application/json",
+    ...buildRobotRockAuthHeaders(config.auth)
+  });
+  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
+        );
+      }
+    },
+    async stageHitlRequests(input) {
+      const validation = agentChatStageHitlBodySchema.safeParse(input);
+      if (!validation.success) {
+        throw new RobotRockError(
+          `Invalid stage HITL input: ${validation.error.issues[0]?.message}`,
+          400,
+          validation.error.issues
+        );
+      }
+      const response = await fetch(`${config.baseUrl}/agent-chats/stage-hitl`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(validation.data)
+      });
+      if (!response.ok) {
+        const data = await parseResponseBody(response);
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to stage chat HITL requests"),
+          response.status,
+          data
+        );
+      }
+    },
+    async getStagedHitlRequests(eveSessionId) {
+      const trimmed = eveSessionId.trim();
+      if (!trimmed) {
+        throw new RobotRockError("eveSessionId is required", 400);
+      }
+      const url = new URL(`${config.baseUrl}/agent-chats/staged-hitl`);
+      url.searchParams.set("eveSessionId", trimmed);
+      const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: headers()
+      });
+      const data = await parseResponseBody(response);
+      if (!response.ok) {
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to fetch staged chat HITL requests"),
+          response.status,
+          data
+        );
+      }
+      const requests = data.requests;
+      return Array.isArray(requests) ? requests : [];
+    },
+    async logInputSubmission(input) {
+      const validation = agentChatAuditInputBodySchema.safeParse(input);
+      if (!validation.success) {
+        throw new RobotRockError(
+          `Invalid audit input: ${validation.error.issues[0]?.message}`,
+          400,
+          validation.error.issues
+        );
+      }
+      const response = await fetch(`${config.baseUrl}/agent-chats/audit-input`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(validation.data)
+      });
+      if (!response.ok) {
+        const data = await parseResponseBody(response);
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to log chat input submission"),
+          response.status,
+          data
+        );
+      }
+    },
+    async logToolExecution(input) {
+      const validation = agentChatAuditToolBodySchema.safeParse(input);
+      if (!validation.success) {
+        throw new RobotRockError(
+          `Invalid audit tool input: ${validation.error.issues[0]?.message}`,
+          400,
+          validation.error.issues
+        );
+      }
+      const response = await fetch(`${config.baseUrl}/agent-chats/audit-tool`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(validation.data)
+      });
+      if (!response.ok) {
+        const data = await parseResponseBody(response);
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to log chat tool execution"),
+          response.status,
+          data
+        );
+      }
+    },
+    async linkTask(input) {
+      const validation = agentChatLinkTaskBodySchema.safeParse(input);
+      if (!validation.success) {
+        throw new RobotRockError(
+          `Invalid link task input: ${validation.error.issues[0]?.message}`,
+          400,
+          validation.error.issues
+        );
+      }
+      const response = await fetch(`${config.baseUrl}/agent-chats/link-task`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(validation.data)
+      });
+      if (!response.ok) {
+        const data = await parseResponseBody(response);
+        throw new RobotRockError(
+          getErrorMessage(data, "Failed to link inbox task to chat"),
+          response.status,
+          data
+        );
+      }
+    }
+  };
+}
+
+// src/client.ts
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
+var DEFAULT_TIMEOUT_MS = 24 * 60 * 60 * 1e3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function resolveAgentVersionFromEnv() {
+  const fromEnv = process.env.AGENT_VERSION?.trim() || process.env.ROBOTROCK_AGENT_VERSION?.trim();
+  return fromEnv || void 0;
+}
+function parseValidUntilMs(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value instanceof Date) {
+    const ms = value.getTime();
+    return Number.isNaN(ms) ? void 0 : ms;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : void 0;
+  }
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function serializeValidUntil(value) {
+  if (value instanceof Date) {
+    const ms = value.getTime();
+    if (Number.isNaN(ms)) {
+      throw new RobotRockError("Invalid validUntil: Date is invalid", 400);
+    }
+    return value.toISOString();
+  }
+  if (typeof value === "string" && !Number.isNaN(Date.parse(value))) {
+    return new Date(value).toISOString();
+  }
+  throw new RobotRockError("Invalid validUntil: expected a Date or parseable date string", 400);
+}
+var RobotRock = class {
+  auth;
+  baseUrl;
+  app;
+  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(
+        "RobotRock client cannot configure both webhook and polling. Use webhook for callbacks or polling to block until handled."
+      );
+    }
+    const apiKey = config.apiKey ?? process.env.ROBOTROCK_API_KEY;
+    const agentService = config.agentService;
+    if (apiKey && agentService) {
+      throw new Error(
+        "RobotRock client cannot configure both apiKey and agentService."
+      );
+    }
+    this.auth = resolveRobotRockAuthConfig({
+      ...apiKey ? { apiKey } : {},
+      ...agentService ? { agentService } : {}
+    });
+    this.baseUrl = config.baseUrl ?? getRobotRockApiBaseUrl();
+    this.app = config.app;
+    this.agentVersion = config.version ?? resolveAgentVersionFromEnv();
+    this.contextVersion = config.advanced?.contextVersion ?? TASK_CONTEXT_FORMAT_VERSION2;
+    this.webhook = config.webhook;
+    this.polling = config.polling ?? {};
+    this.tasks = {
+      create: (task) => this.createTaskRequest(task),
+      get: (taskId) => this.getTaskById(taskId),
+      cancel: (taskId) => this.cancelTaskRequest(taskId),
+      sendUpdate: (input) => this.sendThreadUpdate(input),
+      list: (input) => this.listTasksRequest(input),
+      search: (input) => this.searchTasksRequest(input)
+    };
+    this.chats = createChatsApi({
+      baseUrl: this.baseUrl,
+      auth: this.auth,
+      app: this.app
+    });
+  }
+  authHeaders(extra) {
+    return {
+      "Content-Type": "application/json",
+      ...buildRobotRockAuthHeaders(this.auth),
+      ...extra
+    };
+  }
+  async createTaskRequest(task) {
+    const normalizedTask = normalizeSendToHumanInput(task, {
+      webhook: this.webhook,
+      app: this.app,
+      contextVersion: this.contextVersion,
+      agentVersion: this.agentVersion
+    });
+    const agentVersion = task.version ?? this.agentVersion;
+    const bodyPayload = {
+      ...normalizedTask,
+      ...task.assignTo !== void 0 ? { assignTo: task.assignTo } : {},
+      ...task.threadId !== void 0 ? { threadId: task.threadId } : {},
+      ...task.priority !== void 0 ? { priority: task.priority } : {},
+      ...task.update !== void 0 ? { update: task.update } : {},
+      ...agentVersion !== void 0 ? { agent: { version: agentVersion } } : {}
+    };
+    const validation = createTaskBodySchema2.safeParse(bodyPayload);
+    if (!validation.success) {
+      throw new RobotRockError(
+        `Invalid task: ${validation.error.issues[0]?.message}`,
+        400,
+        validation.error.issues
+      );
+    }
+    const headers = this.authHeaders(
+      task.idempotencyKey ? { "Idempotency-Key": task.idempotencyKey } : void 0
+    );
+    const response = await fetch(`${this.baseUrl}/`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(validation.data)
+    });
+    const data = await parseResponseBody(response);
+    if (!response.ok) {
+      throw new RobotRockError(
+        getErrorMessage(data, "Failed to create task"),
+        response.status,
+        data
+      );
+    }
+    return data.task;
+  }
+  async sendToHuman(task) {
+    const normalizedTask = normalizeSendToHumanInput(task, {
+      webhook: this.webhook,
+      app: this.app,
+      contextVersion: this.contextVersion,
+      agentVersion: this.agentVersion
+    });
+    const createdTaskTask = await this.createTaskRequest(task);
+    const hasHandlers = normalizedTask.actions.some(
+      (action) => Array.isArray(action.handlers) && action.handlers.length > 0
+    );
+    if (hasHandlers) {
+      return {
+        mode: "created",
+        task: createdTaskTask
+      };
+    }
+    const timeoutMs = this.polling.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const pollIntervalMs = this.polling.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const pollingDeadline = Date.now() + timeoutMs;
+    const validUntilMs = parseValidUntilMs(createdTaskTask.validUntil);
+    const deadline = validUntilMs !== void 0 ? Math.min(pollingDeadline, validUntilMs) : pollingDeadline;
+    const taskId = createdTaskTask.taskId;
+    while (Date.now() < deadline) {
+      const existing = await this.getTaskById(taskId);
+      if (existing?.status === "handled" && existing.handled) {
+        return {
+          mode: "handled",
+          task: createdTaskTask,
+          ...toDiscriminatedApprovalResult(
+            normalizedTask.actions,
+            existing
+          )
+        };
+      }
+      if (existing?.status === "expired" || existing && Date.now() >= existing.validUntil) {
+        throw new TaskExpiredError("Task reached validUntil before a human completed it");
+      }
+      const remainingMs = deadline - Date.now();
+      await sleep(Math.min(pollIntervalMs, Math.max(0, remainingMs)));
+    }
+    if (validUntilMs !== void 0 && Date.now() >= validUntilMs) {
+      throw new TaskExpiredError("Task reached validUntil before a human completed it");
+    }
+    throw new TaskTimeoutError(`No human response within ${timeoutMs}ms`);
+  }
+  /**
+   * Create a task via POST /v1 without waiting for a human response.
+   * @deprecated Use `client.tasks.create()` instead.
+   */
+  async createTask(task) {
+    return this.tasks.create(task);
+  }
+  /**
+   * Get a task by public task id (returned as `task.taskId` from {@link sendToHuman}).
+   * @deprecated Use `client.tasks.get()` instead.
+   */
+  async getTask(taskId) {
+    return this.tasks.get(taskId);
+  }
+  /**
+   * Log a status update against a thread.
+   * @deprecated Use `client.tasks.sendUpdate()` instead.
+   */
+  async sendUpdate(input) {
+    return this.tasks.sendUpdate(input);
+  }
+  /**
+   * Cancel a task by public task id.
+   * @deprecated Use `client.tasks.cancel()` instead.
+   */
+  async cancelTask(taskId) {
+    return this.tasks.cancel(taskId);
+  }
+  async getTaskById(taskId) {
+    const response = await fetch(`${this.baseUrl}/tasks/${taskId}`, {
+      method: "GET",
+      headers: this.authHeaders()
+    });
+    if (response.status === 404) {
+      return null;
+    }
+    const data = await parseResponseBody(response);
+    if (!response.ok) {
+      throw new RobotRockError(
+        getErrorMessage(data, "Failed to get task"),
+        response.status,
+        data
+      );
+    }
+    return data;
+  }
+  async sendThreadUpdate({
+    threadId,
+    message,
+    status
+  }) {
+    if (!threadId) {
+      throw new RobotRockError("threadId is required to send an update", 400);
+    }
+    const validation = threadUpdateBodySchema.safeParse({ message, status });
+    if (!validation.success) {
+      throw new RobotRockError(
+        `Invalid update: ${validation.error.issues[0]?.message}`,
+        400,
+        validation.error.issues
+      );
+    }
+    const response = await fetch(
+      `${this.baseUrl}/threads/${encodeURIComponent(threadId)}/updates`,
+      {
+        method: "POST",
+        headers: this.authHeaders(),
+        body: JSON.stringify(validation.data)
+      }
+    );
+    const data = await parseResponseBody(response);
+    if (!response.ok) {
+      throw new RobotRockError(
+        getErrorMessage(data, "Failed to send update"),
+        response.status,
+        data
+      );
+    }
+    return data.update;
+  }
+  async cancelTaskRequest(taskId) {
+    const response = await fetch(`${this.baseUrl}/tasks/${taskId}/cancel`, {
+      method: "POST",
+      headers: this.authHeaders()
+    });
+    if (!response.ok) {
+      const data = await parseResponseBody(response);
+      throw new RobotRockError(
+        getErrorMessage(data, "Failed to cancel task"),
+        response.status,
+        data
+      );
+    }
+  }
+  async listTasksRequest(input) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(input ?? {})) {
+      if (value !== void 0 && value !== "") {
+        params.set(key, String(value));
+      }
+    }
+    const suffix = params.size > 0 ? `?${params.toString()}` : "";
+    const response = await fetch(`${this.baseUrl}/tasks${suffix}`, {
+      method: "GET",
+      headers: this.authHeaders()
+    });
+    const data = await parseResponseBody(response);
+    if (!response.ok) {
+      throw new RobotRockError(
+        getErrorMessage(data, "Failed to list tasks"),
+        response.status,
+        data
+      );
+    }
+    return data;
+  }
+  async searchTasksRequest(input) {
+    const params = new URLSearchParams({ q: input.q });
+    if (input.limit !== void 0) {
+      params.set("limit", String(input.limit));
+    }
+    const response = await fetch(`${this.baseUrl}/tasks/search?${params.toString()}`, {
+      method: "GET",
+      headers: this.authHeaders()
+    });
+    const data = await parseResponseBody(response);
+    if (!response.ok) {
+      throw new RobotRockError(
+        getErrorMessage(data, "Failed to search tasks"),
+        response.status,
+        data
+      );
+    }
+    return data;
+  }
+};
+function createClient(config) {
+  return new RobotRock(config);
+}
+function attachWebhookToActions(actions, webhook) {
+  return actions.map((action) => ({
+    ...action,
+    handlers: webhookToHandlers(webhook)
+  }));
+}
+function webhookToHandlers(webhook) {
+  return [
+    {
+      type: "webhook",
+      url: webhook.url,
+      headers: webhook.headers ?? {}
+    }
+  ];
+}
+function normalizeSendToHumanInput(task, clientDefaults) {
+  const {
+    actions,
+    idempotencyKey: _idempotencyKey,
+    assignTo: _assignTo,
+    threadId: _threadId,
+    priority: _priority,
+    update: _update,
+    version: _version,
+    validUntil,
+    app: taskApp,
+    ...rest
+  } = task;
+  const webhook = clientDefaults.webhook;
+  const normalizedActions = webhook ? attachWebhookToActions(actions, webhook) : actions;
+  const app = taskApp ?? clientDefaults.app;
+  return {
+    ...rest,
+    contextVersion: clientDefaults.contextVersion,
+    ...app ? { app } : {},
+    ...validUntil !== void 0 ? { validUntil: serializeValidUntil(validUntil) } : {},
+    actions: normalizedActions
+  };
+}
+
+// src/env.ts
+function resolveRobotRockConfig(overrides) {
+  const agentService = overrides?.agentService;
+  const apiKey = overrides?.apiKey ?? process.env.ROBOTROCK_API_KEY;
+  if (agentService && apiKey) {
+    throw new Error(
+      "RobotRock client cannot configure both apiKey and agentService."
+    );
+  }
+  const baseUrl = overrides?.baseUrl ?? getRobotRockApiBaseUrl();
+  const app = overrides?.app ?? process.env.ROBOTROCK_APP;
+  if (agentService) {
+    return app ? { agentService, baseUrl, app } : { agentService, baseUrl };
+  }
+  if (!apiKey) {
+    throw new Error(
+      "RobotRock API key is required. Set ROBOTROCK_API_KEY or pass agentService when creating the client."
+    );
+  }
+  return app ? { apiKey, baseUrl, app } : { apiKey, baseUrl };
+}
+
+// src/eve/agent/attributes.ts
+function readStringAttribute(attributes, key) {
+  const value = attributes?.[key];
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  if (Array.isArray(value) && typeof value[0] === "string" && value[0].length > 0) {
+    return value[0];
+  }
+  return void 0;
+}
+function readStringArrayAttribute(attributes, key) {
+  const value = attributes?.[key];
+  if (typeof value === "string" && value.length > 0) {
+    return [value];
+  }
+  if (Array.isArray(value)) {
+    return value.filter(
+      (entry) => typeof entry === "string" && entry.length > 0
+    );
+  }
+  return [];
+}
+function parseTenantRole(value) {
+  if (value === "admin" || value === "member") {
+    return value;
+  }
+  return null;
+}
+
+// src/eve/agent/tenant.ts
+function tryResolveTenantCaller(ctx) {
+  const caller = ctx.session.auth.initiator ?? ctx.session.auth.current;
+  if (caller?.principalType !== "user") {
+    return null;
+  }
+  const email = readStringAttribute(caller.attributes, "email");
+  const name = readStringAttribute(caller.attributes, "name");
+  const tenantSlug = readStringAttribute(caller.attributes, "tenantSlug") ?? readStringAttribute(caller.attributes, "tenantId");
+  const role = parseTenantRole(readStringAttribute(caller.attributes, "role"));
+  if (!email || !tenantSlug || !caller.principalId || !role) {
+    return null;
+  }
+  const workosUserId = readStringAttribute(caller.attributes, "workosUserId");
+  const connectionId = readStringAttribute(caller.attributes, "connectionId");
+  const groups = readStringArrayAttribute(caller.attributes, "groups");
+  return {
+    userId: caller.principalId,
+    email,
+    name: name ?? email.split("@")[0] ?? email,
+    tenantSlug,
+    ...connectionId ? { connectionId } : {},
+    role,
+    isAdmin: role === "admin",
+    groups,
+    ...workosUserId ? { workosUserId } : {}
+  };
+}
+function requireTenantCaller(ctx) {
+  const caller = tryResolveTenantCaller(ctx);
+  if (!caller) {
+    throw new Error("An authenticated RobotRock tenant user is required.");
+  }
+  return caller;
+}
+function requireAdminCaller(ctx) {
+  const caller = requireTenantCaller(ctx);
+  if (!caller.isAdmin) {
+    throw new Error("Tenant admin access is required.");
+  }
+  return caller;
+}
+
+// src/eve/agent/client-from-session.ts
+var warnedMissingAuth = false;
+function tryCreateBoundRobotRockClient(ctx) {
+  const caller = tryResolveTenantCaller(ctx);
+  const serviceToken = process.env.ROBOTROCK_AGENT_SERVICE_TOKEN?.trim();
+  if (caller?.connectionId && serviceToken) {
+    return createClient({
+      baseUrl: process.env.ROBOTROCK_BASE_URL?.trim(),
+      agentService: {
+        token: serviceToken,
+        tenantSlug: caller.tenantSlug,
+        connectionId: caller.connectionId
+      }
+    });
+  }
+  const apiKey = process.env.ROBOTROCK_API_KEY?.trim();
+  if (apiKey) {
+    return createClient(
+      resolveRobotRockConfig({
+        apiKey,
+        baseUrl: process.env.ROBOTROCK_BASE_URL?.trim()
+      })
+    );
+  }
+  if (!warnedMissingAuth) {
+    warnedMissingAuth = true;
+    console.warn(
+      "robotrock: set ROBOTROCK_AGENT_SERVICE_TOKEN for hosted multi-tenant auth, or ROBOTROCK_API_KEY for single-tenant deployments."
+    );
+  }
+  return null;
+}
+
+// src/eve/agent/task-delegation.ts
+function resolveTaskApp(app) {
+  return app?.trim() || process.env.ROBOTROCK_APP?.trim() || "robotrock-agent";
+}
+function resolveWebhookBaseUrl(baseUrl) {
+  return baseUrl?.trim() || process.env.ROBOTROCK_BASE_URL?.trim() || "http://localhost:4001/v1";
+}
+function resolveTaskHandledWebhookUrl(baseUrl) {
+  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  const withV1 = trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
+  return `${withV1}/agent-chats/task-handled`;
+}
+function requireBoundClient(ctx) {
+  const client = tryCreateBoundRobotRockClient(ctx);
+  if (!client) {
+    throw new Error(
+      "RobotRock auth is unset. Configure ROBOTROCK_AGENT_SERVICE_TOKEN for hosted agents or ROBOTROCK_API_KEY for self-hosted deployments."
+    );
+  }
+  return client;
+}
+async function createRobotRockTask(input, ctx) {
+  const client = requireBoundClient(ctx);
+  const { app, ...taskInput } = input;
+  const resolvedApp = resolveTaskApp(app);
+  const webhookUrl = resolveTaskHandledWebhookUrl(
+    resolveWebhookBaseUrl(process.env.ROBOTROCK_BASE_URL)
+  );
+  try {
+    const task = await client.tasks.create({
+      ...taskInput,
+      app: resolvedApp,
+      actions: attachWebhookToActions(taskInput.actions, {
+        url: webhookUrl,
+        headers: {}
+      })
+    });
+    return {
+      taskId: task.taskId,
+      threadId: task.threadId,
+      status: task.status,
+      validUntil: task.validUntil,
+      submittedAt: task.submittedAt
+    };
+  } catch (error) {
+    const caller = tryResolveTenantCaller(ctx);
+    if (error instanceof RobotRockError) {
+      const response = error.response && typeof error.response === "object" ? error.response : void 0;
+      console.error("[create_robotrock_task] API request failed", {
+        status: error.statusCode,
+        message: error.message,
+        code: response?.code,
+        hint: response?.hint,
+        tenantSlug: caller?.tenantSlug,
+        connectionId: caller?.connectionId,
+        baseUrl: process.env.ROBOTROCK_BASE_URL?.trim() || null
+      });
+    } else {
+      console.error("[create_robotrock_task] unexpected error", error);
+    }
+    throw error;
+  }
+}
+function buildRobotRockTaskPayload(input, options) {
+  const contextData = {
+    ...input.context?.data ?? {}
+  };
+  if (options?.requestedByEmail) {
+    contextData.requestedBy = options.requestedByEmail;
+  }
+  const hasContext = Object.keys(contextData).length > 0 || input.context?.ui && Object.keys(input.context.ui).length > 0;
+  const payload = {
+    type: input.type,
+    name: input.name,
+    ...input.description ? { description: input.description } : {},
+    actions: input.actions.map((action) => ({
+      id: action.id,
+      title: action.title,
+      ...action.description ? { description: action.description } : {}
+    })),
+    ...input.assignTo ? { assignTo: input.assignTo } : {},
+    ...input.priority ? { priority: input.priority } : {},
+    ...input.app ? { app: input.app } : {},
+    ...input.validUntilHours ? {
+      validUntil: new Date(Date.now() + input.validUntilHours * 60 * 60 * 1e3)
+    } : {},
+    ...input.updateMessage ? {
+      update: {
+        message: input.updateMessage,
+        status: "waiting"
+      }
+    } : {}
+  };
+  if (hasContext) {
+    payload.context = {
+      data: contextData,
+      ...input.context?.ui ? { ui: input.context.ui } : {}
+    };
+  }
+  return payload;
+}
+
+// src/eve/agent/chat-audit-api.ts
+var warnedMissingAuth2 = false;
+var warnedConnectionRefused = false;
+function isConnectionRefused(error) {
+  const inspect = (value) => {
+    if (!value || typeof value !== "object") {
+      return false;
+    }
+    if ("code" in value && value.code === "ECONNREFUSED") {
+      return true;
+    }
+    if ("cause" in value) {
+      return inspect(value.cause);
+    }
+    if ("errors" in value && Array.isArray(value.errors)) {
+      return value.errors.some((entry) => inspect(entry));
+    }
+    return false;
+  };
+  return inspect(error);
+}
+function logAuditFailure(label, error) {
+  if (isConnectionRefused(error)) {
+    if (!warnedConnectionRefused) {
+      warnedConnectionRefused = true;
+      console.warn(
+        "robotrock-chat-audit: RobotRock API is not reachable (connection refused). Audit and task-link calls are skipped until the API is up."
+      );
+    }
+    return;
+  }
+  const hint = error instanceof RobotRockError && error.statusCode === 405 ? " \u2014 set ROBOTROCK_BASE_URL=http://localhost:4001/v1 and run the local API" : "";
+  console.warn(`robotrock-chat-audit: failed to ${label}${hint}`, error);
+}
+async function postRobotRockLinkChatTask(ctx, input) {
+  const client = tryCreateBoundRobotRockClient(ctx);
+  if (!client) {
+    if (!warnedMissingAuth2) {
+      warnedMissingAuth2 = true;
+      console.warn(
+        "robotrock-task-link: RobotRock auth is unset; skipping chat task link."
+      );
+    }
+    return;
+  }
+  try {
+    await client.chats.linkTask(input);
+  } catch (error) {
+    logAuditFailure("link task to chat", error);
+  }
+}
+
+// src/eve/tool-reply-guidance.ts
+var TOOL_REPLY_GUIDANCE_FIELD = "replyGuidance";
+var WHOAMI_REPLY_GUIDANCE = "The dashboard shows a profile card with name, email, workspace, role, and groups. Do not restate those in your reply. Only add context not in the card (e.g. permissions, refund approval rules, missing group membership).";
+var MY_ACCESS_REPLY_GUIDANCE = "Access details may render in chat UI. Do not restate role, groups, or admin capabilities if already visible. Only explain what the user can or cannot do for their question (e.g. finance group required for refunds \u2265 $10,000). When access.tenantAdmin is false and the user needs manageTeam, manageGroups, or query-tasks capabilities, explain briefly then call ask_question to offer sending an admin request to tenant admins \u2014 do not tell them to find an admin manually without offering delegation first.";
+var CREATE_INBOX_TASK_REPLY_GUIDANCE = "A task card shows title, assignee, and inbox status in chat. Do not restate task ID, assignee, or delegation details from the card. Only mention next steps or answer the user's question.";
+var SEARCH_PRODUCTS_REPLY_GUIDANCE = "Product results render as a list card in chat. Do not restate product names, prices, or SKUs. Only add context not in the list (e.g. no matches, recommendations).";
+var MANAGE_TEAM_MEMBERS_LIST_REPLY_GUIDANCE = "Team members render as a list card in chat. Do not restate names, emails, or roles from the list. Only add context not shown (e.g. duplicates, next admin actions).";
+var MANAGE_TEAM_MEMBERS_DETAIL_REPLY_GUIDANCE = "Team member details render in chat UI. Do not restate name, email, or role from the card. Only add next steps or policy context.";
+var MANAGE_GROUPS_LIST_REPLY_GUIDANCE = "Groups render as a list card in chat. Do not restate group names, slugs, or descriptions from the list. Use slug (not internal id) for get, update, delete, and membership actions. Only add context not shown.";
+var MANAGE_GROUPS_DETAIL_REPLY_GUIDANCE = "Group details render in chat UI. Do not restate fields already visible in the card. Only add next steps.";
+var QUERY_TASKS_LIST_REPLY_GUIDANCE = "Tasks render as a list card in chat. Do not restate task names, ids, or statuses from the list. Only add context not shown (e.g. filters applied, recommended next action).";
+var QUERY_TASKS_DETAIL_REPLY_GUIDANCE = "Task details render in chat UI. Do not restate fields already visible in the card. Only add analysis or next steps.";
+var ASSIGN_TASKS_REPLY_GUIDANCE = "Reassignment results render in chat UI. Do not restate task ids or assignee emails from the card. Only mention failures, partial success, or next steps.";
+var ADMIN_MUTATION_REPLY_GUIDANCE = "The action result renders in chat UI. Do not restate fields already visible in the card. Confirm outcome briefly or add next steps only.";
+function withReplyGuidance(result, guidance) {
+  return {
+    ...result,
+    [TOOL_REPLY_GUIDANCE_FIELD]: guidance
+  };
+}
+
+// src/eve/tools/inbox/create-task.ts
+var CREATE_INBOX_TASK_TOOL_NAME = "create_robotrock_task";
+var actionSchema = z6.object({
+  id: z6.string().min(1).describe("Stable action id, e.g. approve or reject."),
+  title: z6.string().min(1).describe("Button label shown in the inbox."),
+  description: z6.string().min(1).optional()
+});
+var assignToSchema3 = z6.object({
+  users: z6.array(z6.string().email()).optional().describe("Assignee emails \u2014 only these users (plus group members) see the task."),
+  groups: z6.array(z6.string().min(1)).optional().describe(
+    'Group slugs, e.g. "finance" or virtual "admins". Virtual "all" means everyone; omit assignTo for the same effect.'
+  )
+}).optional().refine(
+  (value) => value === void 0 || (value.users?.length ?? 0) > 0 || (value.groups?.length ?? 0) > 0,
+  { message: "assignTo needs at least one user email or group slug." }
+).refine(
+  (value) => {
+    const groups = value?.groups ?? [];
+    if (groups.includes("all") && groups.length > 1) {
+      return false;
+    }
+    return true;
+  },
+  { message: 'Cannot combine "all" with other group slugs' }
+);
+var contextSchema = z6.object({
+  data: z6.record(z6.string(), z6.unknown()).optional().describe("Structured fields shown in the inbox task detail."),
+  ui: z6.record(z6.string(), z6.unknown()).optional().describe(
+    "Optional ui:* hints keyed by context.data field name (ui:widget, ui:title, ui:options). Use currency for amounts, date for ISO timestamps, link/image for URLs. Load the robotrock skill \u2192 context-widgets reference for the full widget catalog."
+  )
+}).optional();
+var createInboxTaskInputSchema = z6.object({
+  type: z6.string().min(1).describe("Task category slug, e.g. refund-approval or budget-approval."),
+  name: z6.string().min(1).describe("Short title shown in the inbox list."),
+  description: z6.string().min(1).optional(),
+  actions: z6.array(actionSchema).min(1).describe("At least one reviewer action (approve, reject, etc.)."),
+  assignTo: assignToSchema3.describe(
+    "Limit visibility to specific users and/or groups. Omit to show the task to everyone in the tenant."
+  ),
+  context: contextSchema,
+  validUntilHours: z6.number().positive().optional().describe("Optional deadline in hours from now. Defaults to the tenant task TTL."),
+  priority: z6.enum(["low", "normal", "high", "urgent"]).optional(),
+  updateMessage: z6.string().min(1).optional().describe("Optional thread status update logged when the task is created."),
+  delegationReason: z6.string().min(1).optional().describe(
+    "User-facing explanation of why the requester cannot self-approve and the task was routed elsewhere. Required when assignTo excludes the caller."
+  )
+});
+function defaultResolveDelegationReason(input) {
+  const assigneeGroups = input.assignTo?.groups?.filter(Boolean) ?? [];
+  if (assigneeGroups.length > 0) {
+    return `This was routed to ${assigneeGroups.join(", ")} for review because you are not in the assignee group.`;
+  }
+  return void 0;
+}
+function defineCreateInboxTaskTool(options) {
+  return defineTool({
+    description: "Create a RobotRock inbox task and assign it to users or groups. Does not wait for a response. Only call this after the user explicitly asked to create/send/delegate an inbox task, or after they confirmed via ask_question. Never create a task silently when the user only asked for a preview, dummy example, or explanation. Always set delegationReason when assignTo excludes the caller. For refund approvals include chargeId, amount, currency, and reason in context.data. The dashboard renders a task card \u2014 do not restate task ID, assignee, or delegation details in your reply.",
+    inputSchema: createInboxTaskInputSchema,
+    async execute(input, ctx) {
+      const caller = requireTenantCaller(ctx);
+      const payload = buildRobotRockTaskPayload(input, {
+        requestedByEmail: caller.email
+      });
+      if (options?.defaultApp && !payload.app) {
+        payload.app = options.defaultApp;
+      }
+      const task = await createRobotRockTask(payload, ctx);
+      const delegationReason = options?.resolveDelegationReason?.(input, caller) ?? input.delegationReason?.trim() ?? defaultResolveDelegationReason(input);
+      await postRobotRockLinkChatTask(ctx, {
+        eveSessionId: ctx.session.id,
+        publicTaskId: task.taskId,
+        toolCallId: ctx.callId
+      });
+      return withReplyGuidance(
+        {
+          ...task,
+          name: input.name,
+          assignedTo: input.assignTo ?? null,
+          requestedBy: caller.email,
+          delegationReason: delegationReason ?? null,
+          message: delegationReason ? `${delegationReason} This chat updates when the assignee decides.` : "Task created in RobotRock. Assignees can handle it from their inbox; this chat will update when they decide."
+        },
+        CREATE_INBOX_TASK_REPLY_GUIDANCE
+      );
+    }
+  });
+}
+var createInboxTaskTool = defineCreateInboxTaskTool();
+
+// src/eve/tools/identity/my-access.ts
+import { defineTool as defineTool2 } from "eve/tools";
+import { z as z7 } from "zod";
+
+// src/eve/tool-result-display.ts
+function toolDisplayResult(data, options) {
+  const display = options?.widget || options?.title || options?.description ? {
+    ...options.widget ? { widget: options.widget } : {},
+    ...options.title ? { title: options.title } : {},
+    ...options.description ? { description: options.description } : {}
+  } : void 0;
+  return {
+    ...display ? { display } : {},
+    data,
+    ...options?.ui ? { ui: options.ui } : {}
+  };
+}
+
+// src/eve/tool-display-format.ts
+function formatToolObjectResult(data, options) {
+  return withReplyGuidance(
+    toolDisplayResult(data, {
+      title: options.title,
+      description: options.description,
+      ui: options.ui
+    }),
+    options.replyGuidance
+  );
+}
+function formatToolListResult(listKey, items, options) {
+  const listFieldUi = options.itemWidget ? {
+    "ui:widget": "list",
+    items: {
+      "ui:widget": options.itemWidget,
+      ...options.itemUi ?? {}
+    }
+  } : {
+    "ui:widget": "table",
+    ...options.itemUi ? { items: options.itemUi } : {}
+  };
+  return formatToolObjectResult(
+    { [listKey]: items },
+    {
+      title: options.title,
+      ui: {
+        [listKey]: listFieldUi
+      },
+      replyGuidance: options.replyGuidance
+    }
+  );
+}
+
+// src/eve/tools/identity/format-my-access.ts
+var ACCESS_FIELD_UI = {
+  workspace: { "ui:title": "Workspace" },
+  role: { "ui:title": "Role" },
+  tenantAdmin: { "ui:title": "Tenant admin", "ui:widget": "boolean" },
+  groups: { "ui:title": "Groups" },
+  manageSettings: { "ui:title": "Manage settings", "ui:widget": "boolean" },
+  manageBilling: { "ui:title": "Manage billing", "ui:widget": "boolean" },
+  manageTeam: { "ui:title": "Manage team", "ui:widget": "boolean" },
+  manageIntegrations: {
+    "ui:title": "Manage integrations",
+    "ui:widget": "boolean"
+  },
+  email: { "ui:title": "Email" }
+};
+function formatMyAccessResult(input) {
+  return formatToolObjectResult(
+    {
+      access: {
+        workspace: input.tenantSlug,
+        role: input.tenantRole ?? "member",
+        tenantAdmin: input.isTenantAdmin,
+        groups: input.groupSlugs.join(", ") || "\u2014",
+        manageSettings: input.capabilities.manageSettings,
+        manageBilling: input.capabilities.manageBilling,
+        manageTeam: input.capabilities.manageTeam,
+        manageIntegrations: input.capabilities.manageIntegrations,
+        ...input.email ? { email: input.email } : {}
+      }
+    },
+    {
+      ui: {
+        access: {
+          "ui:widget": "access",
+          "ui:title": "Your access",
+          items: ACCESS_FIELD_UI
+        }
+      },
+      replyGuidance: MY_ACCESS_REPLY_GUIDANCE
+    }
+  );
+}
+
+// src/eve/tools/identity/my-access.ts
+var MY_ACCESS_TOOL_NAME = "get_my_access";
+var myAccessInputSchema = z7.object({});
+function tenantCapabilities(isAdmin) {
+  return {
+    manageSettings: isAdmin,
+    manageBilling: isAdmin,
+    manageTeam: isAdmin,
+    manageIntegrations: isAdmin
+  };
+}
+function defineMyAccessTool() {
+  return defineTool2({
+    description: "Check the authenticated user's tenant role, group memberships, and admin capabilities in RobotRock. Results render as an access card in chat \u2014 do not restate role, groups, or capabilities in your reply.",
+    inputSchema: myAccessInputSchema,
+    async execute(_input, ctx) {
+      const caller = tryResolveTenantCaller(ctx);
+      if (!caller) {
+        return withReplyGuidance(
+          {
+            authenticated: false,
+            message: "No RobotRock user is attached to this session. Dashboard chat supplies user context via the Eve proxy."
+          },
+          "Explain that no user is attached to this session. Do not invent access details."
+        );
+      }
+      return formatMyAccessResult({
+        tenantSlug: caller.tenantSlug,
+        tenantRole: caller.role,
+        isTenantAdmin: caller.isAdmin,
+        groupSlugs: caller.groups,
+        capabilities: tenantCapabilities(caller.isAdmin),
+        email: caller.email
+      });
+    }
+  });
+}
+var myAccessTool = defineMyAccessTool();
+
+// src/eve/tools/identity/whoami.ts
+import { defineTool as defineTool3 } from "eve/tools";
+import { z as z8 } from "zod";
+var WHOAMI_TOOL_NAME = "whoami";
+var whoamiInputSchema = z8.object({});
+function defineWhoamiTool() {
+  return defineTool3({
+    description: "Return the authenticated RobotRock user, tenant, role, and group memberships for the current chat session. The dashboard renders a profile card \u2014 do not repeat name, email, workspace, role, or groups in your reply; only add context not shown in the card.",
+    inputSchema: whoamiInputSchema,
+    async execute(_input, ctx) {
+      const caller = tryResolveTenantCaller(ctx);
+      if (!caller) {
+        return withReplyGuidance(
+          {
+            authenticated: false,
+            message: "No RobotRock user is attached to this session. Dashboard chat supplies user context via the Eve proxy."
+          },
+          "Explain that no user is attached to this session. Do not invent identity details."
+        );
+      }
+      return withReplyGuidance(
+        {
+          authenticated: true,
+          userId: caller.userId,
+          name: caller.name,
+          email: caller.email,
+          tenantSlug: caller.tenantSlug,
+          role: caller.role,
+          isAdmin: caller.isAdmin,
+          groups: caller.groups.map((slug) => ({ slug })),
+          ...caller.workosUserId ? { workosUserId: caller.workosUserId } : {},
+          sessionId: ctx.session.id
+        },
+        WHOAMI_REPLY_GUIDANCE
+      );
+    }
+  });
+}
+var whoamiTool = defineWhoamiTool();
+
+// src/eve/tools/catalog/search-products.ts
+import { defineTool as defineTool4 } from "eve/tools";
+import { z as z9 } from "zod";
+var SEARCH_PRODUCTS_TOOL_NAME = "search_products";
+var searchProductsInputSchema = z9.object({
+  query: z9.string().min(1).describe("Product name or SKU to search for.")
+});
+var DEMO_PRODUCTS = [
+  {
+    id: "sku-1001",
+    name: "Wireless Keyboard",
+    price: 79.99,
+    currency: "USD",
+    inStock: true
+  },
+  {
+    id: "sku-2042",
+    name: "USB-C Hub",
+    price: 45.99,
+    currency: "USD",
+    inStock: true
+  },
+  {
+    id: "sku-3308",
+    name: "Monitor Stand",
+    price: 129.99,
+    currency: "USD",
+    inStock: false
+  }
+];
+function defineSearchProductsTool() {
+  return defineTool4({
+    description: "Search the product catalog and return matching items with rich list UI. Results render as a product list card \u2014 do not restate product names, prices, or SKUs in your reply.",
+    inputSchema: searchProductsInputSchema,
+    async execute({ query }) {
+      const normalized = query.trim().toLowerCase();
+      const items = DEMO_PRODUCTS.filter(
+        (product) => product.name.toLowerCase().includes(normalized) || product.id.toLowerCase().includes(normalized)
+      );
+      return withReplyGuidance(
+        toolDisplayResult(
+          { items: [...items] },
+          {
+            title: items.length === 1 ? "1 product" : `${items.length} products`,
+            ui: {
+              items: {
+                "ui:widget": "list",
+                "ui:title": "Results",
+                items: {
+                  "ui:widget": "productInfo"
+                }
+              }
+            }
+          }
+        ),
+        SEARCH_PRODUCTS_REPLY_GUIDANCE
+      );
+    }
+  });
+}
+var searchProductsTool = defineSearchProductsTool();
+
+// src/agent-admin.ts
+async function agentAdminFetch(config, path, init) {
+  const baseUrl = (config.baseUrl?.trim() || getRobotRockApiBaseUrl()).replace(
+    /\/+$/,
+    ""
+  );
+  const url = `${baseUrl}/agent-admin${path}`;
+  const response = await fetch(url, {
+    ...init,
+    headers: {
+      "Content-Type": "application/json",
+      ...buildRobotRockAuthHeaders(config.auth),
+      ...init?.headers ?? {}
+    }
+  });
+  const data = await parseResponseBody(response);
+  if (!response.ok) {
+    throw new RobotRockError(
+      getErrorMessage(data, `Agent admin request failed (${response.status})`),
+      response.status,
+      data
+    );
+  }
+  return data;
+}
+function createAgentAdminApi(config) {
+  return {
+    members: {
+      list: () => agentAdminFetch(config, "/members"),
+      get: (memberRef) => agentAdminFetch(config, `/members/${encodeURIComponent(memberRef)}`),
+      invite: (body) => agentAdminFetch(config, "/members", {
+        method: "POST",
+        body: JSON.stringify(body)
+      }),
+      updateRole: (memberRef, role) => agentAdminFetch(
+        config,
+        `/members/${encodeURIComponent(memberRef)}/role`,
+        {
+          method: "PATCH",
+          body: JSON.stringify({ role })
+        }
+      ),
+      remove: (memberId) => agentAdminFetch(
+        config,
+        `/members/${encodeURIComponent(memberId)}`,
+        {
+          method: "DELETE"
+        }
+      )
+    },
+    groups: {
+      list: () => agentAdminFetch(config, "/groups"),
+      get: (groupId) => agentAdminFetch(
+        config,
+        `/groups/${encodeURIComponent(groupId)}`
+      ),
+      create: (body) => agentAdminFetch(config, "/groups", {
+        method: "POST",
+        body: JSON.stringify(body)
+      }),
+      update: (groupId, body) => agentAdminFetch(
+        config,
+        `/groups/${encodeURIComponent(groupId)}`,
+        {
+          method: "PATCH",
+          body: JSON.stringify(body)
+        }
+      ),
+      delete: (groupId) => agentAdminFetch(
+        config,
+        `/groups/${encodeURIComponent(groupId)}`,
+        {
+          method: "DELETE"
+        }
+      ),
+      addMember: (groupRef, memberRef) => agentAdminFetch(
+        config,
+        `/groups/${encodeURIComponent(groupRef)}/members`,
+        {
+          method: "POST",
+          body: JSON.stringify({ userId: memberRef })
+        }
+      ),
+      removeMember: (groupRef, memberRef) => agentAdminFetch(
+        config,
+        `/groups/${encodeURIComponent(groupRef)}/members/${encodeURIComponent(memberRef)}`,
+        { method: "DELETE" }
+      )
+    },
+    tasks: {
+      list: (query) => {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(query ?? {})) {
+          if (value !== void 0 && value !== "") {
+            params.set(key, String(value));
+          }
+        }
+        const suffix = params.size > 0 ? `?${params.toString()}` : "";
+        return agentAdminFetch(
+          config,
+          `/tasks${suffix}`
+        );
+      },
+      search: (q, limit) => {
+        const params = new URLSearchParams({ q });
+        if (limit !== void 0) {
+          params.set("limit", String(limit));
+        }
+        return agentAdminFetch(
+          config,
+          `/tasks/search?${params.toString()}`
+        );
+      },
+      get: (taskId) => agentAdminFetch(config, `/tasks/${taskId}`),
+      assign: (body) => agentAdminFetch(config, "/tasks/assign", {
+        method: "POST",
+        body: JSON.stringify(body)
+      })
+    }
+  };
+}
+function createBoundAgentAdminClient(ctx) {
+  const caller = requireTenantCaller(ctx);
+  const baseUrl = process.env.ROBOTROCK_BASE_URL?.trim();
+  const serviceToken = process.env.ROBOTROCK_AGENT_SERVICE_TOKEN?.trim();
+  if (caller.connectionId && serviceToken) {
+    return createAgentAdminApi({
+      baseUrl,
+      auth: resolveRobotRockAuthConfig({
+        agentService: {
+          token: serviceToken,
+          tenantSlug: caller.tenantSlug,
+          connectionId: caller.connectionId,
+          actingUserId: caller.userId
+        }
+      })
+    });
+  }
+  const apiKey = process.env.ROBOTROCK_API_KEY?.trim();
+  if (apiKey) {
+    return createAgentAdminApi({
+      baseUrl,
+      auth: {
+        kind: "apiKey",
+        apiKey,
+        actingUserId: caller.userId
+      }
+    });
+  }
+  throw new Error(
+    "Agent admin auth is unset. Set ROBOTROCK_AGENT_SERVICE_TOKEN for hosted multi-tenant agents, or ROBOTROCK_API_KEY for self-hosted and localhost deployments."
+  );
+}
+function requireBoundAgentAdminClient(ctx) {
+  requireAdminCaller(ctx);
+  return createBoundAgentAdminClient(ctx);
+}
+
+// src/eve/tools/admin/format-team-members-list.ts
+var MEMBER_DETAIL_UI = {
+  name: { "ui:title": "Name" },
+  email: { "ui:title": "Email" },
+  role: { "ui:title": "Role" },
+  membershipKind: { "ui:title": "Membership" }
+};
+function serializeMemberRow(member) {
+  return {
+    name: member.user.name,
+    email: member.user.email,
+    role: member.role,
+    membershipKind: member.membershipKind
+  };
+}
+function formatTeamMembersListResult(members) {
+  const countLabel = members.length === 1 ? "1 team member" : `${members.length} team members`;
+  return formatToolListResult(
+    "members",
+    members.map(serializeMemberRow),
+    {
+      title: countLabel,
+      itemWidget: "tenantMember",
+      replyGuidance: MANAGE_TEAM_MEMBERS_LIST_REPLY_GUIDANCE
+    }
+  );
+}
+function formatTeamMemberDetailResult(member, options) {
+  return formatToolObjectResult(serializeMemberRow(member), {
+    title: options?.title ?? member.user.name,
+    ui: MEMBER_DETAIL_UI,
+    replyGuidance: MANAGE_TEAM_MEMBERS_DETAIL_REPLY_GUIDANCE
+  });
+}
+
+// src/eve/tools/admin/manage-team-members.ts
+import { defineTool as defineTool5 } from "eve/tools";
+import { z as z10 } from "zod";
+var MANAGE_TEAM_MEMBERS_TOOL_NAME = "manage_team_members";
+var manageTeamMembersInputSchema = z10.object({
+  action: z10.enum(["list", "get", "invite", "update_role", "remove"]),
+  userId: z10.string().min(1).optional().describe(
+    "Convex users table id for get, update_role, and remove. Prefer email when the member list only shows email."
+  ),
+  email: z10.string().email().optional().describe(
+    "Member email for get, update_role, and remove; invitee email for invite."
+  ),
+  role: z10.enum(["admin", "member"]).optional().describe("Role for invite and update_role.")
+}).superRefine((input, ctx) => {
+  const requireField = (field, message) => {
+    if (!input[field]) {
+      ctx.addIssue({ code: "custom", message, path: [field] });
+    }
+  };
+  const requireUserIdOrEmail = (message) => {
+    if (!input.userId && !input.email) {
+      ctx.addIssue({ code: "custom", message, path: ["email"] });
+    }
+  };
+  switch (input.action) {
+    case "get":
+      requireUserIdOrEmail("userId or email is required for this action.");
+      break;
+    case "remove":
+      requireUserIdOrEmail(
+        "userId or email is required when removing a member."
+      );
+      break;
+    case "invite":
+      requireField("email", "email is required when inviting a member.");
+      break;
+    case "update_role":
+      requireUserIdOrEmail(
+        "userId or email is required when updating a role."
+      );
+      requireField("role", "role is required when updating a role.");
+      break;
+  }
+});
+function resolveMemberRef(input) {
+  return input.userId ?? input.email;
+}
+function formatMemberMutationResult(payload, title) {
+  return formatToolObjectResult(payload, {
+    title,
+    ui: {
+      success: { "ui:title": "Success", "ui:widget": "boolean" },
+      promoted: { "ui:title": "Promoted existing user", "ui:widget": "boolean" }
+    },
+    replyGuidance: ADMIN_MUTATION_REPLY_GUIDANCE
+  });
+}
+function defineManageTeamMembersTool() {
+  return defineTool5({
+    description: "Tenant-admin tool for workspace team members: list, get, invite, change role, or remove. Requires tenant admin access. Use member email from list results for get, update_role, and remove \u2014 internal ids are optional. Results render as chat UI cards \u2014 do not restate member names, emails, or roles in your reply.",
+    inputSchema: manageTeamMembersInputSchema,
+    async execute(input, ctx) {
+      const api = requireBoundAgentAdminClient(ctx);
+      try {
+        switch (input.action) {
+          case "list": {
+            const result = await api.members.list();
+            return formatTeamMembersListResult(
+              result.members
+            );
+          }
+          case "get": {
+            const result = await api.members.get(resolveMemberRef(input));
+            return formatTeamMemberDetailResult(result.member);
+          }
+          case "invite": {
+            const result = await api.members.invite({
+              email: input.email,
+              role: input.role
+            });
+            if (result.member) {
+              return formatTeamMemberDetailResult(
+                result.member,
+                { title: "Member invited" }
+              );
+            }
+            return formatMemberMutationResult(
+              result,
+              "Invitation sent"
+            );
+          }
+          case "update_role": {
+            const result = await api.members.updateRole(
+              resolveMemberRef(input),
+              input.role
+            );
+            return formatMemberMutationResult(
+              result,
+              "Member role updated"
+            );
+          }
+          case "remove": {
+            const memberId = resolveMemberRef(input);
+            const result = await api.members.remove(memberId);
+            return formatMemberMutationResult(
+              result,
+              "Member removed"
+            );
+          }
+        }
+      } catch (error) {
+        if (error instanceof RobotRockError) {
+          return {
+            ok: false,
+            status: error.statusCode,
+            message: error.message,
+            response: error.response
+          };
+        }
+        throw error;
+      }
+    }
+  });
+}
+var manageTeamMembersTool = defineManageTeamMembersTool();
+
+// src/eve/tools/admin/manage-groups.ts
+import { defineTool as defineTool6 } from "eve/tools";
+import { z as z11 } from "zod";
+
+// src/eve/tools/admin/format-groups-list.ts
+var GROUP_ITEM_UI = {
+  name: { "ui:title": "Name" },
+  slug: { "ui:title": "Slug" },
+  description: { "ui:title": "Description" },
+  memberCount: { "ui:title": "Members", "ui:widget": "number" }
+};
+function serializeGroupRow(group) {
+  return {
+    name: group.name,
+    slug: group.slug,
+    description: group.description,
+    memberCount: group.memberCount ?? null
+  };
+}
+function formatGroupsListResult(groups) {
+  const countLabel = groups.length === 1 ? "1 group" : `${groups.length} groups`;
+  return formatToolListResult(
+    "groups",
+    groups.map(serializeGroupRow),
+    {
+      title: countLabel,
+      itemWidget: "tenantGroup",
+      replyGuidance: MANAGE_GROUPS_LIST_REPLY_GUIDANCE
+    }
+  );
+}
+function formatGroupDetailResult(group) {
+  return formatToolObjectResult(
+    {
+      name: group.name,
+      slug: group.slug,
+      description: group.description,
+      members: group.members.map((member) => ({
+        name: member.user.name,
+        email: member.user.email
+      }))
+    },
+    {
+      title: group.name,
+      ui: {
+        name: { "ui:title": "Name" },
+        slug: { "ui:title": "Slug" },
+        description: { "ui:title": "Description" },
+        members: {
+          "ui:widget": "list",
+          "ui:title": "Members",
+          items: {
+            name: { "ui:title": "Name" },
+            email: { "ui:title": "Email" }
+          }
+        }
+      },
+      replyGuidance: MANAGE_GROUPS_DETAIL_REPLY_GUIDANCE
+    }
+  );
+}
+function formatGroupSummaryResult(group) {
+  return formatToolObjectResult(serializeGroupRow(group), {
+    title: group.name,
+    ui: GROUP_ITEM_UI,
+    replyGuidance: MANAGE_GROUPS_DETAIL_REPLY_GUIDANCE
+  });
+}
+
+// src/eve/tools/admin/manage-groups.ts
+var MANAGE_GROUPS_TOOL_NAME = "manage_groups";
+var manageGroupsInputSchema = z11.object({
+  action: z11.enum([
+    "list",
+    "get",
+    "create",
+    "update",
+    "delete",
+    "add_member",
+    "remove_member"
+  ]),
+  groupId: z11.string().min(1).optional().describe(
+    "Convex group id for get, update, delete, and membership actions. Prefer slug when the group list only shows slug."
+  ),
+  slug: z11.string().min(1).optional().describe(
+    "Group slug (e.g. finance) for get, update, delete, and membership actions."
+  ),
+  userId: z11.string().min(1).optional().describe(
+    "User id for add_member and remove_member. Prefer email when the member list only shows email."
+  ),
+  email: z11.string().email().optional().describe("Member email for add_member and remove_member."),
+  name: z11.string().min(1).optional().describe("Group name for create and update."),
+  description: z11.string().optional().describe("Group description for create and update.")
+}).superRefine((input, ctx) => {
+  const requireField = (field, message) => {
+    if (!input[field]) {
+      ctx.addIssue({ code: "custom", message, path: [field] });
+    }
+  };
+  const requireGroupIdOrSlug = (message) => {
+    if (!input.groupId && !input.slug) {
+      ctx.addIssue({ code: "custom", message, path: ["slug"] });
+    }
+  };
+  const requireUserIdOrEmail = (message) => {
+    if (!input.userId && !input.email) {
+      ctx.addIssue({ code: "custom", message, path: ["email"] });
+    }
+  };
+  switch (input.action) {
+    case "get":
+    case "delete":
+      requireGroupIdOrSlug(
+        "groupId or slug is required for this action."
+      );
+      break;
+    case "create":
+      requireField("name", "name is required when creating a group.");
+      break;
+    case "update":
+      requireGroupIdOrSlug("groupId or slug is required for update.");
+      break;
+    case "add_member":
+    case "remove_member":
+      requireGroupIdOrSlug(
+        "groupId or slug is required for membership changes."
+      );
+      requireUserIdOrEmail(
+        "userId or email is required for membership changes."
+      );
+      break;
+  }
+});
+function formatGroupMutationResult(payload, title) {
+  return formatToolObjectResult(payload, {
+    title,
+    replyGuidance: ADMIN_MUTATION_REPLY_GUIDANCE
+  });
+}
+function resolveGroupRef(input) {
+  return input.groupId ?? input.slug;
+}
+function resolveMemberRef2(input) {
+  return input.userId ?? input.email;
+}
+function defineManageGroupsTool() {
+  return defineTool6({
+    description: "Tenant-admin tool for workspace groups: list, get, create, update, delete, and manage group membership. Requires tenant admin access. Use group slug (e.g. finance) from list results for get and membership actions \u2014 internal ids are optional. Use member email for add_member and remove_member when user ids are unknown. Results render as chat UI cards \u2014 do not restate group or member fields in your reply.",
+    inputSchema: manageGroupsInputSchema,
+    async execute(input, ctx) {
+      const api = requireBoundAgentAdminClient(ctx);
+      try {
+        switch (input.action) {
+          case "list": {
+            const result = await api.groups.list();
+            return formatGroupsListResult(result.groups);
+          }
+          case "get": {
+            const result = await api.groups.get(resolveGroupRef(input));
+            return formatGroupDetailResult(result.group);
+          }
+          case "create": {
+            const result = await api.groups.create({
+              name: input.name,
+              description: input.description
+            });
+            return formatGroupSummaryResult(result.group);
+          }
+          case "update": {
+            const result = await api.groups.update(resolveGroupRef(input), {
+              name: input.name,
+              description: input.description
+            });
+            return formatGroupSummaryResult(result.group);
+          }
+          case "delete": {
+            const result = await api.groups.delete(resolveGroupRef(input));
+            return formatGroupMutationResult(
+              result,
+              "Group deleted"
+            );
+          }
+          case "add_member": {
+            const result = await api.groups.addMember(
+              resolveGroupRef(input),
+              resolveMemberRef2(input)
+            );
+            return formatGroupMutationResult(
+              result,
+              "Group member added"
+            );
+          }
+          case "remove_member": {
+            const result = await api.groups.removeMember(
+              resolveGroupRef(input),
+              resolveMemberRef2(input)
+            );
+            return formatGroupMutationResult(
+              result,
+              "Group member removed"
+            );
+          }
+        }
+      } catch (error) {
+        if (error instanceof RobotRockError) {
+          return {
+            ok: false,
+            status: error.statusCode,
+            message: error.message,
+            response: error.response
+          };
+        }
+        throw error;
+      }
+    }
+  });
+}
+var manageGroupsTool = defineManageGroupsTool();
+
+// src/eve/tools/admin/query-tasks.ts
+import { defineTool as defineTool7 } from "eve/tools";
+import { z as z12 } from "zod";
+
+// src/eve/tools/admin/format-tasks-list.ts
+function resolveTaskCardLabel(task) {
+  return task.name?.trim() || task.description?.trim() || task.type?.trim() || task.id?.trim() || "Untitled task";
+}
+function formatTasksListResult(items, options) {
+  const title = options?.title ?? (items.length === 1 ? "1 task" : `${items.length} tasks`);
+  const result = formatToolListResult(
+    "items",
+    items.map((task) => ({
+      id: task.id,
+      name: resolveTaskCardLabel(task),
+      status: task.status,
+      type: task.type,
+      description: task.description
+    })),
+    {
+      title,
+      itemWidget: "tenantTask",
+      replyGuidance: QUERY_TASKS_LIST_REPLY_GUIDANCE
+    }
+  );
+  if (options?.nextCursor) {
+    return {
+      ...result,
+      data: {
+        ...result.data,
+        nextCursor: options.nextCursor
+      },
+      display: {
+        ...result.display,
+        description: "More tasks available \u2014 pass nextCursor to list again."
+      }
+    };
+  }
+  return result;
+}
+function formatTaskSearchResult(items, total) {
+  return formatTasksListResult(items, {
+    title: total === 1 ? "1 matching task" : `${total} matching tasks`
+  });
+}
+function formatTaskDetailResult(task) {
+  const title = resolveTaskCardLabel({
+    name: typeof task.name === "string" ? task.name : null,
+    description: typeof task.description === "string" ? task.description : null,
+    type: typeof task.type === "string" ? task.type : null,
+    id: typeof task.id === "string" ? task.id : null
+  });
+  return formatToolObjectResult(
+    {
+      id: task.id ?? null,
+      status: task.status ?? null,
+      type: task.type ?? null,
+      name: task.name ?? null,
+      description: task.description ?? null,
+      validUntil: task.validUntil ?? null,
+      createdAt: task.createdAt ?? null
+    },
+    {
+      title,
+      ui: {
+        id: { "ui:title": "Task ID" },
+        status: { "ui:title": "Status" },
+        type: { "ui:title": "Type" },
+        name: { "ui:title": "Name" },
+        description: { "ui:title": "Description" },
+        validUntil: { "ui:title": "Valid until", "ui:widget": "date" },
+        createdAt: { "ui:title": "Created", "ui:widget": "date" }
+      },
+      replyGuidance: QUERY_TASKS_DETAIL_REPLY_GUIDANCE
+    }
+  );
+}
+function formatAssignTasksResult(results, _assignTo) {
+  const succeeded = results.filter((row) => row.success).length;
+  const title = succeeded === results.length ? `${succeeded === 1 ? "1 task" : `${succeeded} tasks`} reassigned` : `${succeeded}/${results.length} tasks reassigned`;
+  return formatToolListResult(
+    "results",
+    results.map((row) => ({
+      id: row.taskId,
+      name: resolveTaskCardLabel({
+        name: row.name,
+        description: row.description,
+        type: row.type,
+        id: row.taskId
+      }),
+      type: row.type ?? null,
+      description: row.description ?? null,
+      status: row.success ? "reassigned" : "failed"
+    })),
+    {
+      title,
+      itemWidget: "tenantTask",
+      replyGuidance: ASSIGN_TASKS_REPLY_GUIDANCE
+    }
+  );
+}
+
+// src/eve/tools/admin/query-tasks.ts
+var QUERY_TASKS_TOOL_NAME = "query_tasks";
+var queryTasksInputSchema = z12.object({
+  action: z12.enum(["list", "get", "search"]),
+  statusFilter: z12.enum(["all", "open", "handled", "expired"]).optional().describe("Filter by task status for list."),
+  typeFilter: z12.string().optional(),
+  appFilter: z12.string().optional(),
+  sortField: z12.enum(["type", "date", "status", "validUntil"]).optional(),
+  sortDirection: z12.enum(["asc", "desc"]).optional(),
+  limit: z12.number().int().positive().max(100).optional(),
+  cursor: z12.string().optional(),
+  taskId: z12.string().min(1).optional().describe("Public task id or Convex tasks table id for get."),
+  query: z12.string().min(1).optional().describe("Search type, name, description, or id for search.")
+}).superRefine((input, ctx) => {
+  switch (input.action) {
+    case "get":
+      if (!input.taskId) {
+        ctx.addIssue({
+          code: "custom",
+          message: "taskId is required for get.",
+          path: ["taskId"]
+        });
+      }
+      break;
+    case "search":
+      if (!input.query) {
+        ctx.addIssue({
+          code: "custom",
+          message: "query is required for search.",
+          path: ["query"]
+        });
+      }
+      break;
+  }
+});
+function defineQueryTasksTool() {
+  return defineTool7({
+    description: "Tenant-admin tool to list, fetch detail, or search inbox tasks in the workspace. Requires tenant admin access. Results render as chat UI cards \u2014 do not restate task names, ids, or statuses in your reply.",
+    inputSchema: queryTasksInputSchema,
+    async execute(input, ctx) {
+      const api = requireBoundAgentAdminClient(ctx);
+      try {
+        switch (input.action) {
+          case "list": {
+            const result = await api.tasks.list({
+              statusFilter: input.statusFilter,
+              typeFilter: input.typeFilter,
+              appFilter: input.appFilter,
+              sortField: input.sortField,
+              sortDirection: input.sortDirection,
+              limit: input.limit,
+              cursor: input.cursor
+            });
+            return formatTasksListResult(result.items, {
+              nextCursor: result.nextCursor
+            });
+          }
+          case "get": {
+            const result = await api.tasks.get(input.taskId);
+            return formatTaskDetailResult(result.task);
+          }
+          case "search": {
+            const result = await api.tasks.search(input.query, input.limit);
+            return formatTaskSearchResult(
+              result.items,
+              result.total
+            );
+          }
+        }
+      } catch (error) {
+        if (error instanceof RobotRockError) {
+          return {
+            ok: false,
+            status: error.statusCode,
+            message: error.message,
+            response: error.response
+          };
+        }
+        throw error;
+      }
+    }
+  });
+}
+var queryTasksTool = defineQueryTasksTool();
+
+// src/eve/tools/admin/assign-tasks.ts
+import { defineTool as defineTool8 } from "eve/tools";
+import { z as z13 } from "zod";
+var ASSIGN_TASKS_TOOL_NAME = "assign_tasks";
+var assignTasksInputSchema = z13.object({
+  taskIds: z13.array(z13.string().min(1)).min(1).max(100).describe(
+    "Public task ids or Convex tasks table ids to reassign. Use query_tasks search/get to resolve ids first."
+  ),
+  assignTo: assignToSchema.refine(
+    (value) => (value.users?.length ?? 0) > 0 || (value.groups?.length ?? 0) > 0,
+    { message: "assignTo needs at least one user email or group slug." }
+  ).describe(
+    'New assignees \u2014 user emails and/or group slugs (e.g. "finance", virtual "admins").'
+  )
+});
+function defineAssignTasksTool() {
+  return defineTool8({
+    description: "Reassign existing inbox tasks to users or groups. Requires access to each task (tenant admins can reassign any task; others only tasks they can see). Use query_tasks to find task ids when needed. Results render as chat UI \u2014 do not restate task ids or assignees in your reply.",
+    inputSchema: assignTasksInputSchema,
+    async execute(input, ctx) {
+      const api = createBoundAgentAdminClient(ctx);
+      try {
+        const result = await api.tasks.assign({
+          taskIds: input.taskIds,
+          assignTo: input.assignTo
+        });
+        return formatAssignTasksResult(result.results, input.assignTo);
+      } catch (error) {
+        if (error instanceof RobotRockError) {
+          return {
+            ok: false,
+            status: error.statusCode,
+            message: error.message,
+            response: error.response
+          };
+        }
+        throw error;
+      }
+    }
+  });
+}
+var assignTasksTool = defineAssignTasksTool();
+
+// src/eve/tools/index.ts
+function createRobotrockTools(options) {
+  const tools = {};
+  if (options?.inbox !== false) {
+    tools[CREATE_INBOX_TASK_TOOL_NAME] = defineCreateInboxTaskTool(
+      options?.inbox === void 0 ? void 0 : options.inbox
+    );
+  }
+  if (options?.identity !== false) {
+    tools[WHOAMI_TOOL_NAME] = whoamiTool;
+    tools[MY_ACCESS_TOOL_NAME] = myAccessTool;
+  }
+  return tools;
+}
+export {
+  ASSIGN_TASKS_TOOL_NAME,
+  CREATE_INBOX_TASK_TOOL_NAME,
+  MANAGE_GROUPS_TOOL_NAME,
+  MANAGE_TEAM_MEMBERS_TOOL_NAME,
+  MY_ACCESS_TOOL_NAME,
+  QUERY_TASKS_TOOL_NAME,
+  SEARCH_PRODUCTS_TOOL_NAME,
+  WHOAMI_TOOL_NAME,
+  assignTasksInputSchema,
+  assignTasksTool,
+  createInboxTaskInputSchema,
+  createInboxTaskTool,
+  createRobotrockTools,
+  defineAssignTasksTool,
+  defineCreateInboxTaskTool,
+  defineManageGroupsTool,
+  defineManageTeamMembersTool,
+  defineMyAccessTool,
+  defineQueryTasksTool,
+  defineSearchProductsTool,
+  defineWhoamiTool,
+  manageGroupsTool,
+  manageTeamMembersTool,
+  myAccessInputSchema,
+  myAccessTool,
+  queryTasksTool,
+  searchProductsInputSchema,
+  searchProductsTool,
+  whoamiInputSchema,
+  whoamiTool
+};
+//# sourceMappingURL=index.js.map