robotrock 0.8.4 → 0.9.0

package/dist/index.js

@@ -164,12 +164,12 @@ function validateUrlValue(value, widget) {
   }
   return null;
 }
-function validateContextPublicUrls(context) {
-  if (!context?.data) {
+function validateContextPublicUrls(context2) {
+  if (!context2?.data) {
     return null;
   }
-  for (const [field, value] of Object.entries(context.data)) {
-    const widget = widgetType(context.ui, field);
+  for (const [field, value] of Object.entries(context2.data)) {
+    const widget = widgetType(context2.ui, field);
     if (!widget) {
       continue;
     }
@@ -224,7 +224,8 @@ var contextDataSchema = z.object({
   data: z.record(z.string(), z.unknown()),
   ui: contextUiSchema
 }).optional();
-var taskContextObjectSchema = z.object({
+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),
@@ -232,9 +233,22 @@ var taskContextObjectSchema = z.object({
   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) {
@@ -278,61 +292,11 @@ var threadUpdateInputSchema = z.object({
 });
 var taskPriorities = ["low", "normal", "high", "urgent"];
 var taskPrioritySchema = z.enum(taskPriorities);
-var nonNegativeInt = z.number().int().nonnegative();
-var agentCostTokensSchema = z.object({
-  input: nonNegativeInt.optional(),
-  output: nonNegativeInt.optional(),
-  total: nonNegativeInt.optional()
-});
-var agentCostSchema = z.object({
-  tokens: agentCostTokensSchema.optional(),
-  eur: z.number().nonnegative().optional(),
-  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(),
-  /** 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({
+  version: z.string().min(1)
+});
+var createTaskBodySchema = taskContextObjectBaseSchema.extend({
   assignTo: assignToSchema.optional(),
   /**
    * Groups related tasks together. When omitted, the server generates one and
@@ -349,9 +313,9 @@ 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 release version — not shown in inbox UI. */
   agent: agentTelemetrySchema.optional()
-}).superRefine(refineContextPublicUrls);
+}).transform(normalizeTaskContextVersion).superRefine(refineContextPublicUrls);
 
 // src/schemas/index.ts
 var safeUrlSchema2 = z2.string().refine((url) => isPublicHttpUrl(url), {
@@ -395,16 +359,29 @@ var contextDataSchema2 = z2.object({
   data: z2.record(z2.string(), z2.unknown()),
   ui: contextUiSchema2
 }).optional();
-var taskContextObjectSchema2 = z2.object({
+var TASK_CONTEXT_FORMAT_VERSION2 = 2;
+var taskContextObjectBaseSchema2 = z2.object({
   app: z2.string().min(1).optional(),
   type: z2.string().min(1),
   name: z2.string().min(1),
   description: z2.string().optional(),
   validUntil: z2.string().optional(),
   context: contextDataSchema2,
+  contextVersion: z2.literal(2).optional(),
+  /** @deprecated Use `contextVersion`. Accepted on ingest only. */
   version: z2.literal(2).optional(),
   actions: z2.array(taskActionSchema2).min(1, "At least one action is required")
 });
+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) {
@@ -457,56 +434,10 @@ var TASK_PRIORITY_RANK = {
   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({
+  version: z2.string().min(1)
+});
+var createTaskBodySchema2 = taskContextObjectBaseSchema2.extend({
   assignTo: assignToSchema2.optional(),
   /**
    * Groups related tasks together. When omitted, the server generates one and
@@ -524,7 +455,7 @@ var createTaskBodySchema2 = taskContextObjectSchema2.extend({
    */
   update: threadUpdateInputSchema2.optional(),
   agent: agentTelemetrySchema2.optional()
-}).superRefine(refineContextPublicUrls2);
+}).transform(normalizeTaskContextVersion2).superRefine(refineContextPublicUrls2);
 var threadUpdateBodySchema = threadUpdateInputSchema2;
 
 // src/approval-result.ts
@@ -560,6 +491,10 @@ 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;
@@ -599,7 +534,8 @@ var RobotRock = class {
   apiKey;
   baseUrl;
   app;
-  version;
+  agentVersion;
+  contextVersion;
   webhook;
   polling;
   constructor(config) {
@@ -618,7 +554,8 @@ var RobotRock = class {
     const rawBase = config.baseUrl ?? "https://api.robotrock.io/v1";
     this.baseUrl = rawBase.replace(/\/+$/, "");
     this.app = config.app;
-    this.version = config.version ?? 2;
+    this.agentVersion = config.version ?? resolveAgentVersionFromEnv();
+    this.contextVersion = config.advanced?.contextVersion ?? TASK_CONTEXT_FORMAT_VERSION2;
     this.webhook = config.webhook;
     this.polling = config.polling ?? {};
   }
@@ -629,15 +566,17 @@ var RobotRock = class {
     const normalizedTask = normalizeSendToHumanInput(task, {
       webhook: this.webhook,
       app: this.app,
-      version: this.version
+      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 } : {},
-      ...task.agent !== void 0 ? { agent: task.agent } : {}
+      ...agentVersion !== void 0 ? { agent: { version: agentVersion } } : {}
     };
     const validation = createTaskBodySchema2.safeParse(bodyPayload);
     if (!validation.success) {
@@ -673,7 +612,8 @@ var RobotRock = class {
     const normalizedTask = normalizeSendToHumanInput(task, {
       webhook: this.webhook,
       app: this.app,
-      version: this.version
+      contextVersion: this.contextVersion,
+      agentVersion: this.agentVersion
     });
     const createdTaskTask = await this.createTask(task);
     const hasHandlers = normalizedTask.actions.some(
@@ -817,6 +757,7 @@ function normalizeSendToHumanInput(task, clientDefaults) {
     threadId: _threadId,
     priority: _priority,
     update: _update,
+    version: _version,
     validUntil,
     app: taskApp,
     ...rest
@@ -826,7 +767,7 @@ function normalizeSendToHumanInput(task, clientDefaults) {
   const app = taskApp ?? clientDefaults.app;
   return {
     ...rest,
-    version: clientDefaults.version,
+    contextVersion: clientDefaults.contextVersion,
     ...app ? { app } : {},
     ...validUntil !== void 0 ? { validUntil: serializeValidUntil(validUntil) } : {},
     actions: normalizedActions
@@ -885,6 +826,97 @@ function resolveRobotRockClient(client, configOverrides) {
   return createClient(resolveRobotRockConfig(configOverrides));
 }
 
+// src/platform-actions.ts
+var PLATFORM_MARK_DONE_ACTION_ID = "robotrock:mark-done";
+var PLATFORM_REJECT_REQUEST_ACTION_ID = "robotrock:reject-request";
+var PLATFORM_MARK_DONE_ACTION_TITLE = "Mark as done";
+var PLATFORM_REJECT_REQUEST_ACTION_TITLE = "Reject request";
+var PLATFORM_TERMINAL_ACTION_IDS = [
+  PLATFORM_MARK_DONE_ACTION_ID,
+  PLATFORM_REJECT_REQUEST_ACTION_ID
+];
+var PlatformRejectRequestError = class extends Error {
+  actionId = PLATFORM_REJECT_REQUEST_ACTION_ID;
+  feedback;
+  constructor(feedback, message) {
+    super(message ?? `Human rejected the request: ${feedback}`);
+    this.name = "PlatformRejectRequestError";
+    this.feedback = feedback;
+  }
+};
+function isPlatformMarkDoneAction(actionId) {
+  return actionId === PLATFORM_MARK_DONE_ACTION_ID;
+}
+function isPlatformRejectRequestAction(actionId) {
+  return actionId === PLATFORM_REJECT_REQUEST_ACTION_ID;
+}
+function isPlatformTerminalAction(actionId) {
+  return isPlatformMarkDoneAction(actionId) || isPlatformRejectRequestAction(actionId);
+}
+function parsePlatformRejectRequestData(data) {
+  if (data == null || typeof data !== "object") {
+    return null;
+  }
+  const feedback = data.feedback;
+  if (typeof feedback !== "string") {
+    return null;
+  }
+  const trimmed = feedback.trim();
+  if (!trimmed) {
+    return null;
+  }
+  return { feedback: trimmed };
+}
+function toHandledAt(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return value instanceof Date ? value : new Date(value);
+}
+function parseHandledOutcome(input) {
+  const handledAt = toHandledAt(input.handledAt);
+  const handledBy = input.handledBy;
+  if (isPlatformMarkDoneAction(input.actionId)) {
+    return {
+      source: "platform",
+      kind: "mark-done",
+      actionId: PLATFORM_MARK_DONE_ACTION_ID,
+      data: {},
+      handledBy,
+      handledAt
+    };
+  }
+  if (isPlatformRejectRequestAction(input.actionId)) {
+    return {
+      source: "platform",
+      kind: "reject-request",
+      actionId: PLATFORM_REJECT_REQUEST_ACTION_ID,
+      data: parsePlatformRejectRequestData(input.data) ?? { feedback: "" },
+      handledBy,
+      handledAt
+    };
+  }
+  return {
+    source: "task",
+    actionId: input.actionId,
+    data: input.data ?? {},
+    handledBy,
+    handledAt
+  };
+}
+function assertNotPlatformRejectRequest(actionId, data) {
+  if (!isPlatformRejectRequestAction(actionId)) {
+    return;
+  }
+  const parsed = parsePlatformRejectRequestData(data);
+  throw new PlatformRejectRequestError(
+    parsed?.feedback ?? "No feedback provided"
+  );
+}
+function shouldStopAgentForHandledAction(actionId) {
+  return isPlatformTerminalAction(actionId);
+}
+
 // src/webhook.ts
 import { createHmac, timingSafeEqual } from "crypto";
 import { z as z3 } from "zod";
@@ -900,9 +932,6 @@ var robotRockWebhookPayloadBodySchema = z3.object({
   handledAt: z3.string().min(1),
   handlerType: z3.string().min(1)
 });
-var robotRockWebhookPayloadSchema = robotRockWebhookPayloadBodySchema.extend({
-  headers: z3.record(z3.string(), z3.string())
-});
 var RobotRockWebhookError = class extends Error {
   constructor(message, code, details) {
     super(message);
@@ -991,14 +1020,18 @@ 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);
-}
+// src/record-handled-to-otel.ts
+import {
+  context,
+  trace,
+  SpanStatusCode
+} from "@opentelemetry/api";
+var TRACER_NAME = "robotrock";
+var WAIT_SPAN_NAME = "robotrock.wait_for_human";
+var HANDLED_EVENT_NAME = "robotrock.task_handled";
+var INVALID_TRACE_ID = "00000000000000000000000000000000";
 function isValidTraceId(traceId) {
-  return typeof traceId === "string" && traceId.length > 0 && traceId !== "00000000000000000000000000000000";
+  return typeof traceId === "string" && traceId.length > 0 && traceId !== INVALID_TRACE_ID;
 }
 function resolveSpanContext(span) {
   const active = span ?? trace.getActiveSpan();
@@ -1008,121 +1041,217 @@ function resolveSpanContext(span) {
   }
   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;
+function parseTaskCreatedAt(submittedAt) {
+  if (submittedAt) {
+    const parsed = Date.parse(submittedAt);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
     }
   }
-  const errorCount = countErrorSpans(options.otel?.spans);
-  if (errorCount > 0) {
-    info.errorCount = errorCount;
+  return Date.now();
+}
+function parseHandledAtMs(handledAt) {
+  if (handledAt instanceof Date) {
+    return handledAt.getTime();
   }
-  const keys = Object.keys(info);
-  if (keys.length === 0) {
-    return void 0;
+  if (typeof handledAt === "number") {
+    return handledAt;
   }
-  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;
+  const parsed = Date.parse(handledAt);
+  return Number.isNaN(parsed) ? Date.now() : parsed;
+}
+function toRobotRockHandledOtelInput(handled) {
+  if ("actionId" in handled) {
+    return {
+      taskId: handled.taskId,
+      action: {
+        id: handled.actionId,
+        data: handled.data
+      },
+      handledBy: handled.handledBy,
+      handledAt: handled.handledAt
+    };
   }
-  return info;
+  return {
+    taskId: handled.taskId,
+    action: {
+      id: handled.action.id,
+      title: handled.action.title,
+      data: handled.action.data
+    },
+    handledBy: handled.handledBy,
+    handledAt: handled.handledAt
+  };
+}
+function captureRobotRockOtelHandle(task, options) {
+  const spanCtx = resolveSpanContext(options?.span);
+  return {
+    traceId: spanCtx?.traceId ?? "",
+    spanId: spanCtx?.spanId ?? "",
+    taskId: task.taskId,
+    threadId: task.threadId,
+    taskCreatedAt: parseTaskCreatedAt(task.submittedAt)
+  };
 }
-function buildOtelBlock(options, spanCtx) {
-  const traceId = options.otel?.traceId ?? spanCtx?.traceId;
-  if (!isValidTraceId(traceId)) {
+function startRobotRockHumanWaitSpan(handle, options) {
+  const parent = options?.span ?? trace.getActiveSpan();
+  if (!parent) {
     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;
+  const tracer = trace.getTracer(options?.tracerName ?? TRACER_NAME);
+  const span = tracer.startSpan(
+    WAIT_SPAN_NAME,
+    {},
+    trace.setSpan(context.active(), parent)
+  );
+  span.setAttribute("robotrock.task_id", handle.taskId);
+  if (handle.threadId) {
+    span.setAttribute("robotrock.thread_id", handle.threadId);
+  }
+  return span;
+}
+function recordRobotRockHandledToOtel(handled, options = {}) {
+  const span = options.span ?? trace.getActiveSpan();
+  if (!span) {
+    return;
+  }
+  const input = toRobotRockHandledOtelInput(handled);
+  const handledAtMs = parseHandledAtMs(input.handledAt);
+  const handle = options.handle;
+  const humanWaitMs = handle != null ? Math.max(0, handledAtMs - handle.taskCreatedAt) : void 0;
+  span.setAttribute("robotrock.task_id", input.taskId);
+  span.setAttribute("robotrock.action.id", input.action.id);
+  if (input.action.title) {
+    span.setAttribute("robotrock.action.title", input.action.title);
+  }
+  if (input.handledBy) {
+    span.setAttribute("robotrock.handled_by", input.handledBy);
+  }
+  span.setAttribute("robotrock.handled_at", new Date(handledAtMs).toISOString());
+  if (humanWaitMs != null) {
+    span.setAttribute("robotrock.human_wait_ms", humanWaitMs);
+  }
+  if (input.threadId) {
+    span.setAttribute("robotrock.thread_id", input.threadId);
+  }
+  const eventAttributes = {
+    "robotrock.task_id": input.taskId,
+    "robotrock.action.id": input.action.id
+  };
+  if (input.handledBy) {
+    eventAttributes["robotrock.handled_by"] = input.handledBy;
   }
-  if (rootDurationMs != null) {
-    block.rootDurationMs = rootDurationMs;
+  if (humanWaitMs != null) {
+    eventAttributes["robotrock.human_wait_ms"] = humanWaitMs;
   }
-  if (spans && spans.length > 0) {
-    block.spans = spans;
+  if (options.includeActionData && input.action.data != null) {
+    const serialized = JSON.stringify(input.action.data);
+    const truncated = serialized.length > 512 ? `${serialized.slice(0, 512)}\u2026` : serialized;
+    span.setAttribute("robotrock.action.data", truncated);
+    eventAttributes["robotrock.action.data"] = truncated;
   }
-  return block;
+  span.addEvent(HANDLED_EVENT_NAME, eventAttributes);
 }
-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;
+function endRobotRockHumanWaitSpan(span, handled, options = {}) {
+  if (!span) {
+    return;
+  }
+  const outcome = options.outcome ?? (handled ? "handled" : "timeout");
+  if (handled && outcome === "handled") {
+    recordRobotRockHandledToOtel(handled, {
+      span,
+      handle: options.handle,
+      includeActionData: options.includeActionData
+    });
+    span.setStatus({ code: SpanStatusCode.OK });
+  } else {
+    span.setAttribute("robotrock.outcome", outcome);
+    span.setStatus({
+      code: SpanStatusCode.ERROR,
+      message: outcome === "timeout" ? "Human response timed out before validUntil" : "Human wait failed"
+    });
   }
-  const info = buildInfo(options, spanCtx);
-  if (info) {
-    telemetry.info = info;
+  span.end();
+}
+
+// src/otel-platform.ts
+function shouldRecordRobotRockOtel(recordOtel) {
+  if (recordOtel === true) {
+    return true;
   }
-  const otel = buildOtelBlock(options, spanCtx);
-  if (otel) {
-    telemetry.otel = otel;
+  if (recordOtel === false) {
+    return false;
   }
-  return agentTelemetrySchema2.parse(telemetry);
+  const env = process.env.ROBOTROCK_OTEL_RECORD_HANDLED;
+  return env === "true" || env === "1";
 }
-function toolCallsFromOtelSpans(spans) {
-  const counts = {};
-  for (const span of spans) {
-    counts[span.name] = (counts[span.name] ?? 0) + 1;
+function stripPlatformOtelFields(payload) {
+  const { recordOtel: _recordOtel, otelIncludeActionData: _otelIncludeActionData, ...rest } = payload;
+  return rest;
+}
+function beginRobotRockHumanWaitOtel(task, options = {}) {
+  const recordOtel = shouldRecordRobotRockOtel(options.recordOtel);
+  if (!recordOtel) {
+    return { recordOtel: false };
   }
-  return counts;
+  const handle = captureRobotRockOtelHandle(task);
+  const waitSpan = startRobotRockHumanWaitSpan(handle);
+  return {
+    recordOtel: true,
+    handle,
+    waitSpan,
+    includeActionData: options.otelIncludeActionData
+  };
+}
+function finishRobotRockHumanWaitOtel(session, handled, outcome) {
+  if (!session.recordOtel) {
+    return;
+  }
+  endRobotRockHumanWaitSpan(session.waitSpan, handled, {
+    handle: session.handle,
+    outcome,
+    includeActionData: session.includeActionData
+  });
 }
 export {
-  AGENT_OTEL_SPANS_MAX2 as AGENT_OTEL_SPANS_MAX,
   DEFAULT_TASK_PRIORITY,
   DEFAULT_THREAD_UPDATE_STATUS,
   LOWEST_TASK_PRIORITY,
+  PLATFORM_MARK_DONE_ACTION_ID,
+  PLATFORM_MARK_DONE_ACTION_TITLE,
+  PLATFORM_REJECT_REQUEST_ACTION_ID,
+  PLATFORM_REJECT_REQUEST_ACTION_TITLE,
+  PLATFORM_TERMINAL_ACTION_IDS,
+  PlatformRejectRequestError,
   RobotRock,
   RobotRockError,
   RobotRockWebhookError,
+  TASK_CONTEXT_FORMAT_VERSION2 as TASK_CONTEXT_FORMAT_VERSION,
   TASK_PRIORITY_RANK,
   TaskExpiredError,
   TaskTimeoutError,
-  agentCostSchema2 as agentCostSchema,
-  agentCostTokensSchema2 as agentCostTokensSchema,
-  agentOtelSchema2 as agentOtelSchema,
-  agentOtelSpanStatusSchema2 as agentOtelSpanStatusSchema,
-  agentOtelSpanSummarySchema2 as agentOtelSpanSummarySchema,
-  agentTelemetryFromOtel,
   agentTelemetrySchema2 as agentTelemetrySchema,
-  agentToolCallsSchema2 as agentToolCallsSchema,
+  assertNotPlatformRejectRequest,
   assignToSchema2 as assignToSchema,
   attachWebhookToActions,
+  beginRobotRockHumanWaitOtel,
+  captureRobotRockOtelHandle,
   createClient,
   createTaskBodySchema2 as createTaskBodySchema,
+  endRobotRockHumanWaitSpan,
+  finishRobotRockHumanWaitOtel,
+  isPlatformMarkDoneAction,
+  isPlatformRejectRequestAction,
+  isPlatformTerminalAction,
+  parseHandledOutcome,
+  parsePlatformRejectRequestData,
+  recordRobotRockHandledToOtel,
   resolveRobotRockClient,
   resolveRobotRockConfig,
+  shouldRecordRobotRockOtel,
+  shouldStopAgentForHandledAction,
+  startRobotRockHumanWaitSpan,
+  stripPlatformOtelFields,
   taskContextSchema2 as taskContextSchema,
   taskPriorities2 as taskPriorities,
   taskPrioritySchema2 as taskPrioritySchema,
@@ -1131,7 +1260,7 @@ export {
   threadUpdateStatusSchema2 as threadUpdateStatusSchema,
   threadUpdateStatuses2 as threadUpdateStatuses,
   toDiscriminatedApprovalResult,
-  toolCallsFromOtelSpans,
+  toRobotRockHandledOtelInput,
   verifyRobotRockWebhook
 };
 //# sourceMappingURL=index.js.map