robotrock 0.8.1 → 0.8.4

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 import { R as RobotRock, b as RobotRockConfig } from './client-D-XEBOWd.js';
 export { c as RobotRockError, d as RobotRockPollingClientConfig, e as RobotRockPollingOptions, f as RobotRockWebhookClientConfig, g as RobotRockWebhookConfig, S as SendToHumanActionInput, a as SendToHumanInput, h as SendToHumanResult, i as SendToHumanValidUntil, j as SendUpdateInput, k as attachWebhookToActions, l as createClient } from './client-D-XEBOWd.js';
 import { Task, DiscriminatedApprovalResult } from './schemas/index.js';
-export { AgentCost, AgentCostTokens, AgentTelemetry, AgentTelemetryInput, ApprovalResult, AssignToInput, CreateTaskBody, CreateTaskBodyInput, DEFAULT_TASK_PRIORITY, DEFAULT_THREAD_UPDATE_STATUS, Handler, InferActionData, LOWEST_TASK_PRIORITY, TASK_PRIORITY_RANK, TaskAction, TaskContext, TaskContextInput, TaskPriority, TaskResponse, TaskResult, TaskStatus, ThreadUpdate, ThreadUpdateBody, ThreadUpdateBodyInput, ThreadUpdateInput, ThreadUpdateResponse, ThreadUpdateSource, ThreadUpdateStatus, TriggerHandler, TupleElementIndices, WebhookHandler, agentCostSchema, agentCostTokensSchema, agentTelemetrySchema, assignToSchema, createTaskBodySchema, taskContextSchema, taskPriorities, taskPrioritySchema, threadUpdateBodySchema, threadUpdateInputSchema, threadUpdateStatusSchema, threadUpdateStatuses } from './schemas/index.js';
+export { AGENT_OTEL_SPANS_MAX, AgentCost, AgentCostTokens, AgentOtel, AgentOtelSpanStatus, AgentOtelSpanSummary, AgentTelemetry, AgentTelemetryInput, AgentToolCalls, ApprovalResult, AssignToInput, CreateTaskBody, CreateTaskBodyInput, DEFAULT_TASK_PRIORITY, DEFAULT_THREAD_UPDATE_STATUS, Handler, InferActionData, LOWEST_TASK_PRIORITY, TASK_PRIORITY_RANK, TaskAction, TaskContext, TaskContextInput, TaskPriority, TaskResponse, TaskResult, TaskStatus, ThreadUpdate, ThreadUpdateBody, ThreadUpdateBodyInput, ThreadUpdateInput, ThreadUpdateResponse, ThreadUpdateSource, ThreadUpdateStatus, TriggerHandler, TupleElementIndices, WebhookHandler, agentCostSchema, agentCostTokensSchema, agentOtelSchema, agentOtelSpanStatusSchema, agentOtelSpanSummarySchema, agentTelemetrySchema, agentToolCallsSchema, assignToSchema, createTaskBodySchema, taskContextSchema, taskPriorities, taskPrioritySchema, threadUpdateBodySchema, threadUpdateInputSchema, threadUpdateStatusSchema, threadUpdateStatuses } from './schemas/index.js';
 import { z } from 'zod';
 export { R as RobotRockHandlerWebhookPayload } from './handler-webhook-BqEi6Bk-.js';
+export { AgentTelemetryFromOtelOptions, OtelSpanLike, OtelSpanSummaryInput, agentTelemetryFromOtel, toolCallsFromOtelSpans } from './otel/index.js';
 
 /**
  * Read RobotRock client config from environment variables.

package/dist/index.js

@@ -1,10 +1,187 @@
 // src/schemas/index.ts
+import { z as z2 } 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 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";
+
+// ../core/src/schemas/task.ts
 import { z } from "zod";
-import {
-  isPublicHttpUrl,
-  PUBLIC_HTTP_URL_ERROR
-} from "@robotrock/core/utils";
-import { validateContextPublicUrls } from "@robotrock/core/schemas";
+
+// ../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
 });
@@ -32,6 +209,7 @@ var taskActionSchema = z.object({
   schema: jsonSchema7Schema.optional(),
   ui: uiSchemaSchema.optional(),
   data: z.record(z.string(), z.unknown()).optional(),
+  // Optional handlers for this action - if present, must have at least 1
   handlers: z.array(handlerSchema).min(1).optional()
 });
 var uiFieldSchemaSchema = z.object({
@@ -47,6 +225,7 @@ var contextDataSchema = z.object({
   ui: contextUiSchema
 }).optional();
 var taskContextObjectSchema = z.object({
+  /** Source application id; omitted tasks are grouped in the default inbox. */
   app: z.string().min(1).optional(),
   type: z.string().min(1),
   name: z.string().min(1),
@@ -93,21 +272,12 @@ var threadUpdateStatuses = [
   "cancelled"
 ];
 var threadUpdateStatusSchema = z.enum(threadUpdateStatuses);
-var DEFAULT_THREAD_UPDATE_STATUS = "info";
 var threadUpdateInputSchema = z.object({
   message: threadUpdateMessageSchema,
   status: threadUpdateStatusSchema.optional()
 });
 var taskPriorities = ["low", "normal", "high", "urgent"];
 var taskPrioritySchema = z.enum(taskPriorities);
-var DEFAULT_TASK_PRIORITY = "normal";
-var LOWEST_TASK_PRIORITY = "low";
-var TASK_PRIORITY_RANK = {
-  low: 1,
-  normal: 2,
-  high: 3,
-  urgent: 4
-};
 var nonNegativeInt = z.number().int().nonnegative();
 var agentCostTokensSchema = z.object({
   input: nonNegativeInt.optional(),
@@ -120,17 +290,47 @@ var agentCostSchema = z.object({
   usd: z.number().nonnegative().optional()
 });
 var AGENT_INFO_MAX_KEYS = 32;
+var AGENT_TOOL_CALLS_MAX_KEYS = 64;
+var AGENT_OTEL_SPANS_MAX = 32;
+var agentToolCallsSchema = z.record(z.string().min(1), nonNegativeInt);
+var agentOtelSpanStatusSchema = z.enum(["ok", "error"]);
+var agentOtelSpanSummarySchema = z.object({
+  name: z.string().min(1),
+  durationMs: z.number().nonnegative(),
+  status: agentOtelSpanStatusSchema
+});
+var agentOtelSchema = z.object({
+  traceId: z.string().min(1),
+  spanId: z.string().min(1).optional(),
+  rootDurationMs: z.number().nonnegative().optional(),
+  spans: z.array(agentOtelSpanSummarySchema).max(AGENT_OTEL_SPANS_MAX).optional()
+});
 var agentTelemetrySchema = z.object({
+  /** Agent or app version (semver, git SHA, deploy tag — caller-defined). */
   version: z.string().min(1).optional(),
+  /** Total tool invocations. When omitted but `toolCalls` is set, the sum of counts is used. */
   toolCallCount: nonNegativeInt.optional(),
+  /** Per-tool invocation counts keyed by tool name. */
+  toolCalls: agentToolCallsSchema.optional(),
   cost: agentCostSchema.optional(),
-  info: z.record(z.string(), z.unknown()).optional()
+  /** Free-form metadata for experiments (model, prompt variant, etc.). */
+  info: z.record(z.string(), z.unknown()).optional(),
+  /** Structured OpenTelemetry span snapshot for feedback analysis. */
+  otel: agentOtelSchema.optional()
 }).refine(
   (data) => {
     const keys = data.info ? Object.keys(data.info) : [];
     return keys.length <= AGENT_INFO_MAX_KEYS;
   },
   { message: `agent.info may contain at most ${AGENT_INFO_MAX_KEYS} keys` }
+).refine(
+  (data) => {
+    const keys = data.toolCalls ? Object.keys(data.toolCalls) : [];
+    return keys.length <= AGENT_TOOL_CALLS_MAX_KEYS;
+  },
+  {
+    message: `agent.toolCalls may contain at most ${AGENT_TOOL_CALLS_MAX_KEYS} tool names`
+  }
 );
 var createTaskBodySchema = taskContextObjectSchema.extend({
   assignTo: assignToSchema.optional(),
@@ -149,9 +349,183 @@ var createTaskBodySchema = taskContextObjectSchema.extend({
    * the inbox status bar and the thread update log.
    */
   update: threadUpdateInputSchema.optional(),
+  /** Agent telemetry (version, cost, tool calls) — not shown in inbox UI. */
   agent: agentTelemetrySchema.optional()
 }).superRefine(refineContextPublicUrls);
-var threadUpdateBodySchema = threadUpdateInputSchema;
+
+// src/schemas/index.ts
+var safeUrlSchema2 = z2.string().refine((url) => isPublicHttpUrl(url), {
+  message: PUBLIC_HTTP_URL_ERROR
+});
+var jsonSchema7Schema2 = z2.custom(
+  (val) => typeof val === "object" && val !== null,
+  { message: "Must be a valid JSON Schema object" }
+);
+var uiSchemaSchema2 = z2.custom((val) => typeof val === "object" && val !== null, {
+  message: "Must be a valid UiSchema object"
+});
+var webhookHandlerSchema2 = z2.object({
+  type: z2.literal("webhook"),
+  url: safeUrlSchema2,
+  headers: z2.record(z2.string(), z2.string())
+});
+var triggerHandlerSchema2 = webhookHandlerSchema2.extend({
+  type: z2.literal("trigger"),
+  tokenId: z2.string().min(1)
+});
+var handlerSchema2 = z2.discriminatedUnion("type", [webhookHandlerSchema2, triggerHandlerSchema2]);
+var taskActionSchema2 = z2.object({
+  id: z2.string().min(1),
+  title: z2.string().min(1),
+  description: z2.string().optional(),
+  schema: jsonSchema7Schema2.optional(),
+  ui: uiSchemaSchema2.optional(),
+  data: z2.record(z2.string(), z2.unknown()).optional(),
+  handlers: z2.array(handlerSchema2).min(1).optional()
+});
+var uiFieldSchemaSchema2 = z2.object({
+  "ui:widget": z2.string().optional(),
+  "ui:title": z2.string().optional(),
+  "ui:description": z2.string().optional(),
+  "ui:options": z2.record(z2.string(), z2.unknown()).optional(),
+  items: z2.lazy(() => z2.record(z2.string(), uiFieldSchemaSchema2)).optional()
+}).passthrough();
+var contextUiSchema2 = z2.record(z2.string(), uiFieldSchemaSchema2).optional();
+var contextDataSchema2 = z2.object({
+  data: z2.record(z2.string(), z2.unknown()),
+  ui: contextUiSchema2
+}).optional();
+var taskContextObjectSchema2 = z2.object({
+  app: z2.string().min(1).optional(),
+  type: z2.string().min(1),
+  name: z2.string().min(1),
+  description: z2.string().optional(),
+  validUntil: z2.string().optional(),
+  context: contextDataSchema2,
+  version: z2.literal(2).optional(),
+  actions: z2.array(taskActionSchema2).min(1, "At least one action is required")
+});
+function refineContextPublicUrls2(data, ctx) {
+  const error = validateContextPublicUrls(data.context);
+  if (error) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: error,
+      path: ["context"]
+    });
+  }
+}
+var taskContextSchema2 = taskContextObjectSchema2.superRefine(
+  refineContextPublicUrls2
+);
+var assignToSchema2 = z2.object({
+  users: z2.array(z2.string().email()).optional(),
+  groups: z2.array(z2.string().min(1)).optional()
+}).refine(
+  (data) => {
+    const groups = data.groups ?? [];
+    if (groups.includes("all") && groups.length > 1) {
+      return false;
+    }
+    return true;
+  },
+  { message: 'Cannot combine "all" with other group slugs' }
+);
+var threadUpdateMessageSchema2 = z2.string().min(1).max(500);
+var threadUpdateStatuses2 = [
+  "info",
+  "queued",
+  "running",
+  "waiting",
+  "succeeded",
+  "failed",
+  "cancelled"
+];
+var threadUpdateStatusSchema2 = z2.enum(threadUpdateStatuses2);
+var DEFAULT_THREAD_UPDATE_STATUS = "info";
+var threadUpdateInputSchema2 = z2.object({
+  message: threadUpdateMessageSchema2,
+  status: threadUpdateStatusSchema2.optional()
+});
+var taskPriorities2 = ["low", "normal", "high", "urgent"];
+var taskPrioritySchema2 = z2.enum(taskPriorities2);
+var DEFAULT_TASK_PRIORITY = "normal";
+var LOWEST_TASK_PRIORITY = "low";
+var TASK_PRIORITY_RANK = {
+  low: 1,
+  normal: 2,
+  high: 3,
+  urgent: 4
+};
+var nonNegativeInt2 = z2.number().int().nonnegative();
+var agentCostTokensSchema2 = z2.object({
+  input: nonNegativeInt2.optional(),
+  output: nonNegativeInt2.optional(),
+  total: nonNegativeInt2.optional()
+});
+var agentCostSchema2 = z2.object({
+  tokens: agentCostTokensSchema2.optional(),
+  eur: z2.number().nonnegative().optional(),
+  usd: z2.number().nonnegative().optional()
+});
+var AGENT_INFO_MAX_KEYS2 = 32;
+var AGENT_TOOL_CALLS_MAX_KEYS2 = 64;
+var AGENT_OTEL_SPANS_MAX2 = 32;
+var agentToolCallsSchema2 = z2.record(z2.string().min(1), nonNegativeInt2);
+var agentOtelSpanStatusSchema2 = z2.enum(["ok", "error"]);
+var agentOtelSpanSummarySchema2 = z2.object({
+  name: z2.string().min(1),
+  durationMs: z2.number().nonnegative(),
+  status: agentOtelSpanStatusSchema2
+});
+var agentOtelSchema2 = z2.object({
+  traceId: z2.string().min(1),
+  spanId: z2.string().min(1).optional(),
+  rootDurationMs: z2.number().nonnegative().optional(),
+  spans: z2.array(agentOtelSpanSummarySchema2).max(AGENT_OTEL_SPANS_MAX2).optional()
+});
+var agentTelemetrySchema2 = z2.object({
+  version: z2.string().min(1).optional(),
+  toolCallCount: nonNegativeInt2.optional(),
+  toolCalls: agentToolCallsSchema2.optional(),
+  cost: agentCostSchema2.optional(),
+  info: z2.record(z2.string(), z2.unknown()).optional(),
+  otel: agentOtelSchema2.optional()
+}).refine(
+  (data) => {
+    const keys = data.info ? Object.keys(data.info) : [];
+    return keys.length <= AGENT_INFO_MAX_KEYS2;
+  },
+  { message: `agent.info may contain at most ${AGENT_INFO_MAX_KEYS2} keys` }
+).refine(
+  (data) => {
+    const keys = data.toolCalls ? Object.keys(data.toolCalls) : [];
+    return keys.length <= AGENT_TOOL_CALLS_MAX_KEYS2;
+  },
+  {
+    message: `agent.toolCalls may contain at most ${AGENT_TOOL_CALLS_MAX_KEYS2} tool names`
+  }
+);
+var createTaskBodySchema2 = taskContextObjectSchema2.extend({
+  assignTo: assignToSchema2.optional(),
+  /**
+   * Groups related tasks together. When omitted, the server generates one and
+   * returns it so the caller can reuse it on later tasks in the same thread.
+   */
+  threadId: z2.string().min(1).optional(),
+  /**
+   * Optional thread priority. When set, applies to the whole thread and
+   * overwrites any previous priority. Omit on later tasks to leave unchanged.
+   */
+  priority: taskPrioritySchema2.optional(),
+  /**
+   * Optional initial status update logged against the task's thread. Shows in
+   * the inbox status bar and the thread update log.
+   */
+  update: threadUpdateInputSchema2.optional(),
+  agent: agentTelemetrySchema2.optional()
+}).superRefine(refineContextPublicUrls2);
+var threadUpdateBodySchema = threadUpdateInputSchema2;
 
 // src/approval-result.ts
 var TaskTimeoutError = class extends Error {
@@ -265,7 +639,7 @@ var RobotRock = class {
       ...task.update !== void 0 ? { update: task.update } : {},
       ...task.agent !== void 0 ? { agent: task.agent } : {}
     };
-    const validation = createTaskBodySchema.safeParse(bodyPayload);
+    const validation = createTaskBodySchema2.safeParse(bodyPayload);
     if (!validation.success) {
       throw new RobotRockError(
         `Invalid task: ${validation.error.issues[0]?.message}`,
@@ -513,21 +887,21 @@ function resolveRobotRockClient(client, configOverrides) {
 
 // src/webhook.ts
 import { createHmac, timingSafeEqual } from "crypto";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var ROBOTROCK_SIGNATURE_HEADER = "x-robotrock-signature";
-var robotRockWebhookPayloadBodySchema = z2.object({
-  taskId: z2.string().min(1),
-  action: z2.object({
-    id: z2.string().min(1),
-    title: z2.string().min(1),
-    data: z2.unknown()
+var robotRockWebhookPayloadBodySchema = z3.object({
+  taskId: z3.string().min(1),
+  action: z3.object({
+    id: z3.string().min(1),
+    title: z3.string().min(1),
+    data: z3.unknown()
   }),
-  handledBy: z2.string().min(1).optional(),
-  handledAt: z2.string().min(1),
-  handlerType: z2.string().min(1)
+  handledBy: z3.string().min(1).optional(),
+  handledAt: z3.string().min(1),
+  handlerType: z3.string().min(1)
 });
 var robotRockWebhookPayloadSchema = robotRockWebhookPayloadBodySchema.extend({
-  headers: z2.record(z2.string(), z2.string())
+  headers: z3.record(z3.string(), z3.string())
 });
 var RobotRockWebhookError = class extends Error {
   constructor(message, code, details) {
@@ -616,7 +990,116 @@ function normalizeHeaders(headers) {
   });
   return result;
 }
+
+// src/agent-telemetry-from-otel.ts
+import { trace } from "@opentelemetry/api";
+var AGENT_INFO_MAX_KEYS3 = 32;
+function sumToolCalls(toolCalls) {
+  return Object.values(toolCalls).reduce((sum, count) => sum + count, 0);
+}
+function isValidTraceId(traceId) {
+  return typeof traceId === "string" && traceId.length > 0 && traceId !== "00000000000000000000000000000000";
+}
+function resolveSpanContext(span) {
+  const active = span ?? trace.getActiveSpan();
+  const ctx = active?.spanContext();
+  if (!ctx || !isValidTraceId(ctx.traceId)) {
+    return void 0;
+  }
+  return { traceId: ctx.traceId, spanId: ctx.spanId };
+}
+function countErrorSpans(spans) {
+  if (!spans) return 0;
+  return spans.filter((entry) => entry.status === "error").length;
+}
+function buildInfo(options, spanCtx) {
+  const info = { ...options.extraInfo };
+  if (spanCtx) {
+    info.traceId = spanCtx.traceId;
+    info.spanId = spanCtx.spanId;
+  }
+  if (options.runStartedAt != null) {
+    const durationMs = Date.now() - options.runStartedAt;
+    if (durationMs >= 0) {
+      info.durationMs = durationMs;
+    }
+  }
+  const errorCount = countErrorSpans(options.otel?.spans);
+  if (errorCount > 0) {
+    info.errorCount = errorCount;
+  }
+  const keys = Object.keys(info);
+  if (keys.length === 0) {
+    return void 0;
+  }
+  if (keys.length > AGENT_INFO_MAX_KEYS3) {
+    const trimmed = {};
+    for (const key of keys.slice(0, AGENT_INFO_MAX_KEYS3)) {
+      trimmed[key] = info[key];
+    }
+    return trimmed;
+  }
+  return info;
+}
+function buildOtelBlock(options, spanCtx) {
+  const traceId = options.otel?.traceId ?? spanCtx?.traceId;
+  if (!isValidTraceId(traceId)) {
+    return void 0;
+  }
+  const spans = options.otel?.spans;
+  const rootDurationMs = options.otel?.rootDurationMs ?? (options.runStartedAt != null ? Math.max(0, Date.now() - options.runStartedAt) : void 0);
+  const block = { traceId };
+  const spanId = options.otel?.spanId ?? spanCtx?.spanId;
+  if (spanId) {
+    block.spanId = spanId;
+  }
+  if (rootDurationMs != null) {
+    block.rootDurationMs = rootDurationMs;
+  }
+  if (spans && spans.length > 0) {
+    block.spans = spans;
+  }
+  return block;
+}
+function agentTelemetryFromOtel(options = {}) {
+  const spanCtx = resolveSpanContext(options.span);
+  const telemetry = {};
+  if (options.version) {
+    telemetry.version = options.version;
+  }
+  if (options.toolCalls && Object.keys(options.toolCalls).length > 0) {
+    telemetry.toolCalls = options.toolCalls;
+  }
+  if (options.toolCallCount !== void 0) {
+    telemetry.toolCallCount = options.toolCallCount;
+  } else if (telemetry.toolCalls) {
+    const sum = sumToolCalls(telemetry.toolCalls);
+    if (sum > 0) {
+      telemetry.toolCallCount = sum;
+    }
+  }
+  if (options.cost) {
+    telemetry.cost = options.cost;
+  }
+  const info = buildInfo(options, spanCtx);
+  if (info) {
+    telemetry.info = info;
+  }
+  const otel = buildOtelBlock(options, spanCtx);
+  if (otel) {
+    telemetry.otel = otel;
+  }
+  return agentTelemetrySchema2.parse(telemetry);
+}
+function toolCallsFromOtelSpans(spans) {
+  const counts = {};
+  for (const span of spans) {
+    counts[span.name] = (counts[span.name] ?? 0) + 1;
+  }
+  return counts;
+}
 export {
+  AGENT_OTEL_SPANS_MAX2 as AGENT_OTEL_SPANS_MAX,
   DEFAULT_TASK_PRIORITY,
   DEFAULT_THREAD_UPDATE_STATUS,
   LOWEST_TASK_PRIORITY,
@@ -626,23 +1109,29 @@ export {
   TASK_PRIORITY_RANK,
   TaskExpiredError,
   TaskTimeoutError,
-  agentCostSchema,
-  agentCostTokensSchema,
-  agentTelemetrySchema,
-  assignToSchema,
+  agentCostSchema2 as agentCostSchema,
+  agentCostTokensSchema2 as agentCostTokensSchema,
+  agentOtelSchema2 as agentOtelSchema,
+  agentOtelSpanStatusSchema2 as agentOtelSpanStatusSchema,
+  agentOtelSpanSummarySchema2 as agentOtelSpanSummarySchema,
+  agentTelemetryFromOtel,
+  agentTelemetrySchema2 as agentTelemetrySchema,
+  agentToolCallsSchema2 as agentToolCallsSchema,
+  assignToSchema2 as assignToSchema,
   attachWebhookToActions,
   createClient,
-  createTaskBodySchema,
+  createTaskBodySchema2 as createTaskBodySchema,
   resolveRobotRockClient,
   resolveRobotRockConfig,
-  taskContextSchema,
-  taskPriorities,
-  taskPrioritySchema,
+  taskContextSchema2 as taskContextSchema,
+  taskPriorities2 as taskPriorities,
+  taskPrioritySchema2 as taskPrioritySchema,
   threadUpdateBodySchema,
-  threadUpdateInputSchema,
-  threadUpdateStatusSchema,
-  threadUpdateStatuses,
+  threadUpdateInputSchema2 as threadUpdateInputSchema,
+  threadUpdateStatusSchema2 as threadUpdateStatusSchema,
+  threadUpdateStatuses2 as threadUpdateStatuses,
   toDiscriminatedApprovalResult,
+  toolCallsFromOtelSpans,
   verifyRobotRockWebhook
 };
 //# sourceMappingURL=index.js.map