robotrock 0.8.4 → 0.9.0

package/dist/ai/workflow.js

@@ -259,12 +259,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;
     }
@@ -284,6 +284,13 @@ var init_context_urls = __esm({
 
 // ../core/src/schemas/task.ts
 import { z } from "zod";
+function normalizeTaskContextVersion(data) {
+  const { version: legacyVersion, contextVersion, ...rest } = data;
+  return {
+    ...rest,
+    contextVersion: contextVersion ?? legacyVersion ?? TASK_CONTEXT_FORMAT_VERSION
+  };
+}
 function refineContextPublicUrls(data, ctx) {
   const error = validateContextPublicUrls(data.context);
   if (error) {
@@ -294,7 +301,7 @@ function refineContextPublicUrls(data, ctx) {
     });
   }
 }
-var safeUrlSchema, jsonSchema7Schema, uiSchemaSchema, webhookHandlerSchema, triggerHandlerSchema, handlerSchema, taskActionSchema, uiFieldSchemaSchema, contextUiSchema, contextDataSchema, taskContextObjectSchema, taskContextSchema, assignToSchema, threadUpdateMessageSchema, threadUpdateStatuses, threadUpdateStatusSchema, threadUpdateInputSchema, taskPriorities, taskPrioritySchema, nonNegativeInt, agentCostTokensSchema, agentCostSchema, AGENT_INFO_MAX_KEYS, AGENT_TOOL_CALLS_MAX_KEYS, AGENT_OTEL_SPANS_MAX, agentToolCallsSchema, agentOtelSpanStatusSchema, agentOtelSpanSummarySchema, agentOtelSchema, agentTelemetrySchema, createTaskBodySchema;
+var safeUrlSchema, jsonSchema7Schema, uiSchemaSchema, webhookHandlerSchema, triggerHandlerSchema, handlerSchema, taskActionSchema, uiFieldSchemaSchema, contextUiSchema, contextDataSchema, TASK_CONTEXT_FORMAT_VERSION, taskContextObjectBaseSchema, taskContextObjectSchema, taskContextSchema, assignToSchema, threadUpdateMessageSchema, threadUpdateStatuses, threadUpdateStatusSchema, threadUpdateInputSchema, taskPriorities, taskPrioritySchema, agentTelemetrySchema, createTaskBodySchema;
 var init_task = __esm({
   "../core/src/schemas/task.ts"() {
     "use strict";
@@ -342,7 +349,8 @@ var init_task = __esm({
       data: z.record(z.string(), z.unknown()),
       ui: contextUiSchema
     }).optional();
-    taskContextObjectSchema = z.object({
+    TASK_CONTEXT_FORMAT_VERSION = 2;
+    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),
@@ -350,9 +358,15 @@ var init_task = __esm({
       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")
     });
+    taskContextObjectSchema = taskContextObjectBaseSchema.transform(
+      normalizeTaskContextVersion
+    );
     taskContextSchema = taskContextObjectSchema.superRefine(
       refineContextPublicUrls
     );
@@ -386,61 +400,11 @@ var init_task = __esm({
     });
     taskPriorities = ["low", "normal", "high", "urgent"];
     taskPrioritySchema = z.enum(taskPriorities);
-    nonNegativeInt = z.number().int().nonnegative();
-    agentCostTokensSchema = z.object({
-      input: nonNegativeInt.optional(),
-      output: nonNegativeInt.optional(),
-      total: nonNegativeInt.optional()
-    });
-    agentCostSchema = z.object({
-      tokens: agentCostTokensSchema.optional(),
-      eur: z.number().nonnegative().optional(),
-      usd: z.number().nonnegative().optional()
-    });
-    AGENT_INFO_MAX_KEYS = 32;
-    AGENT_TOOL_CALLS_MAX_KEYS = 64;
-    AGENT_OTEL_SPANS_MAX = 32;
-    agentToolCallsSchema = z.record(z.string().min(1), nonNegativeInt);
-    agentOtelSpanStatusSchema = z.enum(["ok", "error"]);
-    agentOtelSpanSummarySchema = z.object({
-      name: z.string().min(1),
-      durationMs: z.number().nonnegative(),
-      status: agentOtelSpanStatusSchema
-    });
-    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()
-    });
     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`
-      }
-    );
-    createTaskBodySchema = taskContextObjectSchema.extend({
+      version: z.string().min(1)
+    });
+    createTaskBodySchema = taskContextObjectBaseSchema.extend({
       assignTo: assignToSchema.optional(),
       /**
        * Groups related tasks together. When omitted, the server generates one and
@@ -457,9 +421,9 @@ var init_task = __esm({
        * the inbox status bar and the thread update log.
        */
       update: threadUpdateInputSchema.optional(),
-      /** Agent telemetry (version, cost, tool calls) — not shown in inbox UI. */
+      /** Agent release version — not shown in inbox UI. */
       agent: agentTelemetrySchema.optional()
-    }).superRefine(refineContextPublicUrls);
+    }).transform(normalizeTaskContextVersion).superRefine(refineContextPublicUrls);
   }
 });
 
@@ -482,6 +446,13 @@ var init_schemas = __esm({
 
 // src/schemas/index.ts
 import { z as z2 } from "zod";
+function normalizeTaskContextVersion2(data) {
+  const { version: legacyVersion, contextVersion, ...rest } = data;
+  return {
+    ...rest,
+    contextVersion: contextVersion ?? legacyVersion ?? TASK_CONTEXT_FORMAT_VERSION2
+  };
+}
 function refineContextPublicUrls2(data, ctx) {
   const error = validateContextPublicUrls(data.context);
   if (error) {
@@ -492,7 +463,7 @@ function refineContextPublicUrls2(data, ctx) {
     });
   }
 }
-var safeUrlSchema2, jsonSchema7Schema2, uiSchemaSchema2, webhookHandlerSchema2, triggerHandlerSchema2, handlerSchema2, taskActionSchema2, uiFieldSchemaSchema2, contextUiSchema2, contextDataSchema2, taskContextObjectSchema2, taskContextSchema2, assignToSchema2, threadUpdateMessageSchema2, threadUpdateStatuses2, threadUpdateStatusSchema2, threadUpdateInputSchema2, taskPriorities2, taskPrioritySchema2, nonNegativeInt2, agentCostTokensSchema2, agentCostSchema2, AGENT_INFO_MAX_KEYS2, AGENT_TOOL_CALLS_MAX_KEYS2, AGENT_OTEL_SPANS_MAX2, agentToolCallsSchema2, agentOtelSpanStatusSchema2, agentOtelSpanSummarySchema2, agentOtelSchema2, agentTelemetrySchema2, createTaskBodySchema2, threadUpdateBodySchema;
+var safeUrlSchema2, jsonSchema7Schema2, uiSchemaSchema2, webhookHandlerSchema2, triggerHandlerSchema2, handlerSchema2, taskActionSchema2, uiFieldSchemaSchema2, contextUiSchema2, contextDataSchema2, TASK_CONTEXT_FORMAT_VERSION2, taskContextObjectBaseSchema2, taskContextObjectSchema2, taskContextSchema2, assignToSchema2, threadUpdateMessageSchema2, threadUpdateStatuses2, threadUpdateStatusSchema2, threadUpdateInputSchema2, taskPriorities2, taskPrioritySchema2, agentTelemetrySchema2, createTaskBodySchema2, threadUpdateBodySchema;
 var init_schemas2 = __esm({
   "src/schemas/index.ts"() {
     "use strict";
@@ -539,16 +510,22 @@ var init_schemas2 = __esm({
       data: z2.record(z2.string(), z2.unknown()),
       ui: contextUiSchema2
     }).optional();
-    taskContextObjectSchema2 = z2.object({
+    TASK_CONTEXT_FORMAT_VERSION2 = 2;
+    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")
     });
+    taskContextObjectSchema2 = taskContextObjectBaseSchema2.transform(
+      normalizeTaskContextVersion2
+    );
     taskContextSchema2 = taskContextObjectSchema2.superRefine(
       refineContextPublicUrls2
     );
@@ -582,56 +559,10 @@ var init_schemas2 = __esm({
     });
     taskPriorities2 = ["low", "normal", "high", "urgent"];
     taskPrioritySchema2 = z2.enum(taskPriorities2);
-    nonNegativeInt2 = z2.number().int().nonnegative();
-    agentCostTokensSchema2 = z2.object({
-      input: nonNegativeInt2.optional(),
-      output: nonNegativeInt2.optional(),
-      total: nonNegativeInt2.optional()
-    });
-    agentCostSchema2 = z2.object({
-      tokens: agentCostTokensSchema2.optional(),
-      eur: z2.number().nonnegative().optional(),
-      usd: z2.number().nonnegative().optional()
-    });
-    AGENT_INFO_MAX_KEYS2 = 32;
-    AGENT_TOOL_CALLS_MAX_KEYS2 = 64;
-    AGENT_OTEL_SPANS_MAX2 = 32;
-    agentToolCallsSchema2 = z2.record(z2.string().min(1), nonNegativeInt2);
-    agentOtelSpanStatusSchema2 = z2.enum(["ok", "error"]);
-    agentOtelSpanSummarySchema2 = z2.object({
-      name: z2.string().min(1),
-      durationMs: z2.number().nonnegative(),
-      status: agentOtelSpanStatusSchema2
-    });
-    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()
-    });
     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`
-      }
-    );
-    createTaskBodySchema2 = taskContextObjectSchema2.extend({
+      version: z2.string().min(1)
+    });
+    createTaskBodySchema2 = taskContextObjectBaseSchema2.extend({
       assignTo: assignToSchema2.optional(),
       /**
        * Groups related tasks together. When omitted, the server generates one and
@@ -649,7 +580,7 @@ var init_schemas2 = __esm({
        */
       update: threadUpdateInputSchema2.optional(),
       agent: agentTelemetrySchema2.optional()
-    }).superRefine(refineContextPublicUrls2);
+    }).transform(normalizeTaskContextVersion2).superRefine(refineContextPublicUrls2);
     threadUpdateBodySchema = threadUpdateInputSchema2;
   }
 });
@@ -691,6 +622,10 @@ var init_approval_result = __esm({
 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;
@@ -744,6 +679,7 @@ function normalizeSendToHumanInput(task2, clientDefaults) {
     threadId: _threadId,
     priority: _priority,
     update: _update,
+    version: _version,
     validUntil,
     app: taskApp,
     ...rest
@@ -753,7 +689,7 @@ function normalizeSendToHumanInput(task2, clientDefaults) {
   const app = taskApp ?? clientDefaults.app;
   return {
     ...rest,
-    version: clientDefaults.version,
+    contextVersion: clientDefaults.contextVersion,
     ...app ? { app } : {},
     ...validUntil !== void 0 ? { validUntil: serializeValidUntil(validUntil) } : {},
     actions: normalizedActions
@@ -811,7 +747,8 @@ var init_client = __esm({
       apiKey;
       baseUrl;
       app;
-      version;
+      agentVersion;
+      contextVersion;
       webhook;
       polling;
       constructor(config) {
@@ -830,7 +767,8 @@ var init_client = __esm({
         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 ?? {};
       }
@@ -841,15 +779,17 @@ var init_client = __esm({
         const normalizedTask = normalizeSendToHumanInput(task2, {
           webhook: this.webhook,
           app: this.app,
-          version: this.version
+          contextVersion: this.contextVersion,
+          agentVersion: this.agentVersion
         });
+        const agentVersion = task2.version ?? this.agentVersion;
         const bodyPayload = {
           ...normalizedTask,
           ...task2.assignTo !== void 0 ? { assignTo: task2.assignTo } : {},
           ...task2.threadId !== void 0 ? { threadId: task2.threadId } : {},
           ...task2.priority !== void 0 ? { priority: task2.priority } : {},
           ...task2.update !== void 0 ? { update: task2.update } : {},
-          ...task2.agent !== void 0 ? { agent: task2.agent } : {}
+          ...agentVersion !== void 0 ? { agent: { version: agentVersion } } : {}
         };
         const validation = createTaskBodySchema2.safeParse(bodyPayload);
         if (!validation.success) {
@@ -885,7 +825,8 @@ var init_client = __esm({
         const normalizedTask = normalizeSendToHumanInput(task2, {
           webhook: this.webhook,
           app: this.app,
-          version: this.version
+          contextVersion: this.contextVersion,
+          agentVersion: this.agentVersion
         });
         const createdTaskTask = await this.createTask(task2);
         const hasHandlers = normalizedTask.actions.some(
@@ -1027,6 +968,212 @@ var init_env = __esm({
   }
 });
 
+// src/record-handled-to-otel.ts
+import {
+  context,
+  trace,
+  SpanStatusCode
+} from "@opentelemetry/api";
+function isValidTraceId(traceId) {
+  return typeof traceId === "string" && traceId.length > 0 && traceId !== INVALID_TRACE_ID;
+}
+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 parseTaskCreatedAt(submittedAt) {
+  if (submittedAt) {
+    const parsed = Date.parse(submittedAt);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return Date.now();
+}
+function parseHandledAtMs(handledAt) {
+  if (handledAt instanceof Date) {
+    return handledAt.getTime();
+  }
+  if (typeof handledAt === "number") {
+    return handledAt;
+  }
+  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 {
+    taskId: handled.taskId,
+    action: {
+      id: handled.action.id,
+      title: handled.action.title,
+      data: handled.action.data
+    },
+    handledBy: handled.handledBy,
+    handledAt: handled.handledAt
+  };
+}
+function captureRobotRockOtelHandle(task2, options) {
+  const spanCtx = resolveSpanContext(options?.span);
+  return {
+    traceId: spanCtx?.traceId ?? "",
+    spanId: spanCtx?.spanId ?? "",
+    taskId: task2.taskId,
+    threadId: task2.threadId,
+    taskCreatedAt: parseTaskCreatedAt(task2.submittedAt)
+  };
+}
+function startRobotRockHumanWaitSpan(handle, options) {
+  const parent = options?.span ?? trace.getActiveSpan();
+  if (!parent) {
+    return void 0;
+  }
+  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 (humanWaitMs != null) {
+    eventAttributes["robotrock.human_wait_ms"] = humanWaitMs;
+  }
+  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;
+  }
+  span.addEvent(HANDLED_EVENT_NAME, eventAttributes);
+}
+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"
+    });
+  }
+  span.end();
+}
+var TRACER_NAME, WAIT_SPAN_NAME, HANDLED_EVENT_NAME, INVALID_TRACE_ID;
+var init_record_handled_to_otel = __esm({
+  "src/record-handled-to-otel.ts"() {
+    "use strict";
+    TRACER_NAME = "robotrock";
+    WAIT_SPAN_NAME = "robotrock.wait_for_human";
+    HANDLED_EVENT_NAME = "robotrock.task_handled";
+    INVALID_TRACE_ID = "00000000000000000000000000000000";
+  }
+});
+
+// src/otel-platform.ts
+function shouldRecordRobotRockOtel(recordOtel) {
+  if (recordOtel === true) {
+    return true;
+  }
+  if (recordOtel === false) {
+    return false;
+  }
+  const env = process.env.ROBOTROCK_OTEL_RECORD_HANDLED;
+  return env === "true" || env === "1";
+}
+function stripPlatformOtelFields(payload) {
+  const { recordOtel: _recordOtel, otelIncludeActionData: _otelIncludeActionData, ...rest } = payload;
+  return rest;
+}
+function beginRobotRockHumanWaitOtel(task2, options = {}) {
+  const recordOtel = shouldRecordRobotRockOtel(options.recordOtel);
+  if (!recordOtel) {
+    return { recordOtel: false };
+  }
+  const handle = captureRobotRockOtelHandle(task2);
+  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
+  });
+}
+var init_otel_platform = __esm({
+  "src/otel-platform.ts"() {
+    "use strict";
+    init_record_handled_to_otel();
+  }
+});
+
 // src/handler-webhook.ts
 function isRobotRockHandlerWebhookPayload(value) {
   if (typeof value !== "object" || value === null) {
@@ -1107,7 +1254,7 @@ __export(trigger_exports, {
 });
 import { task, wait } from "@trigger.dev/sdk";
 async function runSendToHuman(payload) {
-  const { validUntil: validUntilInput, ...taskInput } = payload;
+  const { validUntil: validUntilInput, app, recordOtel, otelIncludeActionData, ...taskFields } = payload;
   const { validUntil, timeout } = resolveWaitTiming(validUntilInput);
   const token = await wait.createToken({ timeout });
   const baseConfig = resolveRobotRockConfig();
@@ -1116,45 +1263,74 @@ async function runSendToHuman(payload) {
     baseUrl: baseConfig.baseUrl,
     ...baseConfig.app ? { app: baseConfig.app } : {},
     ...baseConfig.version ? { version: baseConfig.version } : {},
+    ...baseConfig.advanced ? { advanced: baseConfig.advanced } : {},
     webhook: { url: token.url }
   });
+  const taskInput = stripPlatformOtelFields(taskFields);
   const sendResult = await client.sendToHuman({
     ...taskInput,
-    validUntil
+    validUntil,
+    ...app !== void 0 ? { app } : {}
   });
-  const outcome = await wait.forToken(token.id);
-  if (!outcome.ok) {
-    throw new Error(`Human response timed out before validUntil (${timeout})`);
-  }
-  const output = outcome.output;
-  if (!isRobotRockHandlerWebhookPayload(output)) {
-    throw new Error(
-      "Wait token completed with unexpected payload; expected RobotRock handler body (taskId, action.id, action.data)."
-    );
-  }
-  return toDiscriminatedApprovalResult(
-    payload.actions,
-    {
-      id: output.taskId,
-      createdAt: /* @__PURE__ */ new Date(),
-      status: "handled",
-      context: sendResult.task.context,
-      validUntil: Date.now(),
-      handledAt: new Date(output.handledAt).getTime(),
-      handled: {
-        action: {
-          id: output.action.id,
-          data: output.action.data
-        },
-        handledBy: output.handledBy
+  const otelSession = beginRobotRockHumanWaitOtel(sendResult.task, {
+    recordOtel,
+    otelIncludeActionData
+  });
+  let handledPayload = null;
+  let waitOutcome = "pending";
+  try {
+    const outcome = await wait.forToken(token.id);
+    if (!outcome.ok) {
+      waitOutcome = "timeout";
+      throw new Error(`Human response timed out before validUntil (${timeout})`);
+    }
+    const output = outcome.output;
+    if (!isRobotRockHandlerWebhookPayload(output)) {
+      waitOutcome = "error";
+      throw new Error(
+        "Wait token completed with unexpected payload; expected RobotRock handler body (taskId, action.id, action.data)."
+      );
+    }
+    handledPayload = output;
+    waitOutcome = "handled";
+    return toDiscriminatedApprovalResult(
+      payload.actions,
+      {
+        id: output.taskId,
+        createdAt: /* @__PURE__ */ new Date(),
+        status: "handled",
+        context: sendResult.task.context,
+        validUntil: Date.now(),
+        handledAt: new Date(output.handledAt).getTime(),
+        handled: {
+          action: {
+            id: output.action.id,
+            data: output.action.data
+          },
+          handledBy: output.handledBy
+        }
       }
+    );
+  } catch (error) {
+    if (waitOutcome === "pending") {
+      waitOutcome = "error";
     }
-  );
+    throw error;
+  } finally {
+    if (waitOutcome !== "pending") {
+      finishRobotRockHumanWaitOtel(
+        otelSession,
+        handledPayload,
+        waitOutcome === "handled" ? "handled" : waitOutcome
+      );
+    }
+  }
 }
 var APPROVE_BY_HUMAN_ACTIONS, sendToHumanTask, approveByHumanTask;
 var init_trigger = __esm({
   "src/trigger/index.ts"() {
     "use strict";
+    init_otel_platform();
     init_client();
     init_env();
     init_approval_result();
@@ -1194,6 +1370,7 @@ async function createRobotRockTaskForWebhook(input) {
     baseUrl: baseConfig.baseUrl,
     ...input.app ?? baseConfig.app ? { app: input.app ?? baseConfig.app } : {},
     ...baseConfig.version ? { version: baseConfig.version } : {},
+    ...baseConfig.advanced ? { advanced: baseConfig.advanced } : {},
     webhook: { url: input.webhookUrl }
   });
   return client.sendToHuman({
@@ -1214,7 +1391,7 @@ async function parseRobotRockWebhookRequest(request) {
 async function sendToHumanInWorkflow(payload) {
   var _stack = [];
   try {
-    const { validUntil: validUntilInput, app, ...taskInput } = payload;
+    const { validUntil: validUntilInput, app, recordOtel, otelIncludeActionData, ...taskFields } = payload;
     const { validUntil, timeout } = resolveWaitTiming(validUntilInput);
     const timeoutMs = parseValidUntilMs2(validUntil) - Date.now();
     const webhook = __using(_stack, createWebhook());
@@ -1222,31 +1399,54 @@ async function sendToHumanInWorkflow(payload) {
       webhookUrl: webhook.url,
       app,
       validUntil,
-      taskInput
+      taskInput: stripPlatformOtelFields(taskFields)
     });
-    const outcome = await Promise.race([
-      webhook.then((request) => parseRobotRockWebhookRequest(request)),
-      sleep2(timeoutMs).then(() => ({ timedOut: true }))
-    ]);
-    if ("timedOut" in outcome) {
-      throw new Error(`Human response timed out before validUntil (${timeout})`);
-    }
-    const output = outcome;
-    return toDiscriminatedApprovalResult(payload.actions, {
-      id: output.taskId,
-      createdAt: /* @__PURE__ */ new Date(),
-      status: "handled",
-      context: sendResult.task.context,
-      validUntil: Date.now(),
-      handledAt: new Date(output.handledAt).getTime(),
-      handled: {
-        action: {
-          id: output.action.id,
-          data: output.action.data
-        },
-        handledBy: output.handledBy
-      }
+    const otelSession = beginRobotRockHumanWaitOtel(sendResult.task, {
+      recordOtel,
+      otelIncludeActionData
     });
+    let handledPayload = null;
+    let waitOutcome = "pending";
+    try {
+      const outcome = await Promise.race([
+        webhook.then((request) => parseRobotRockWebhookRequest(request)),
+        sleep2(timeoutMs).then(() => ({ timedOut: true }))
+      ]);
+      if ("timedOut" in outcome) {
+        waitOutcome = "timeout";
+        throw new Error(`Human response timed out before validUntil (${timeout})`);
+      }
+      handledPayload = outcome;
+      waitOutcome = "handled";
+      return toDiscriminatedApprovalResult(payload.actions, {
+        id: outcome.taskId,
+        createdAt: /* @__PURE__ */ new Date(),
+        status: "handled",
+        context: sendResult.task.context,
+        validUntil: Date.now(),
+        handledAt: new Date(outcome.handledAt).getTime(),
+        handled: {
+          action: {
+            id: outcome.action.id,
+            data: outcome.action.data
+          },
+          handledBy: outcome.handledBy
+        }
+      });
+    } catch (error) {
+      if (waitOutcome === "pending") {
+        waitOutcome = "error";
+      }
+      throw error;
+    } finally {
+      if (waitOutcome !== "pending") {
+        finishRobotRockHumanWaitOtel(
+          otelSession,
+          handledPayload,
+          waitOutcome === "handled" ? "handled" : waitOutcome
+        );
+      }
+    }
   } catch (_) {
     var _error = _, _hasError = true;
   } finally {
@@ -1267,7 +1467,8 @@ async function sendRobotRockUpdate(payload) {
     apiKey: baseConfig.apiKey,
     baseUrl: baseConfig.baseUrl,
     ...app ?? baseConfig.app ? { app: app ?? baseConfig.app } : {},
-    ...baseConfig.version ? { version: baseConfig.version } : {}
+    ...baseConfig.version ? { version: baseConfig.version } : {},
+    ...baseConfig.advanced ? { advanced: baseConfig.advanced } : {}
   });
   return client.sendUpdate(update);
 }
@@ -1283,6 +1484,7 @@ var init_workflow = __esm({
     init_approval_result();
     init_handler_webhook();
     init_wait_timing();
+    init_otel_platform();
     APPROVE_BY_HUMAN_ACTIONS2 = [
       { id: "approve", title: "Approve" },
       { id: "decline", title: "Decline" }
@@ -1321,27 +1523,27 @@ function normalizeRobotRockAiContext(clientOrContext) {
   }
   throw new Error(`Unknown RobotRock AI mode: ${String(clientOrContext.mode)}`);
 }
-async function sendToHumanForAi(context, payload) {
-  if (context.mode === "trigger") {
+async function sendToHumanForAi(context2, payload) {
+  if (context2.mode === "trigger") {
     const { sendToHumanTask: sendToHumanTask2 } = await Promise.resolve().then(() => (init_trigger(), trigger_exports));
     const waitResult = await sendToHumanTask2.triggerAndWait({
       ...payload,
-      ...context.app ? { app: context.app } : {}
+      ...context2.app ? { app: context2.app } : {}
     });
     if (!waitResult.ok) {
       throw waitResult.error;
     }
     return waitResult.output;
   }
-  if (context.mode === "workflow") {
+  if (context2.mode === "workflow") {
     const { sendToHumanInWorkflow: sendToHumanInWorkflow2 } = await Promise.resolve().then(() => (init_workflow(), workflow_exports));
     const result2 = await sendToHumanInWorkflow2({
       ...payload,
-      ...context.app ? { app: context.app } : {}
+      ...context2.app ? { app: context2.app } : {}
     });
     return result2;
   }
-  const result = await context.client.sendToHuman(payload);
+  const result = await context2.client.sendToHuman(payload);
   if (result.mode !== "handled") {
     throw new Error(
       "RobotRock task was created but not handled. Configure client polling or webhook, or use mode: 'trigger' / 'workflow' for durable waits."
@@ -1355,42 +1557,42 @@ async function sendToHumanForAi(context, payload) {
     taskId: result.taskId
   };
 }
-async function sendUpdateForAi(context, payload) {
-  if (context.mode === "workflow") {
+async function sendUpdateForAi(context2, payload) {
+  if (context2.mode === "workflow") {
     const { sendUpdateInWorkflow: sendUpdateInWorkflow2 } = await Promise.resolve().then(() => (init_workflow(), workflow_exports));
     return sendUpdateInWorkflow2({
       ...payload,
-      ...context.app ? { app: context.app } : {}
+      ...context2.app ? { app: context2.app } : {}
     });
   }
-  if (context.mode === "trigger") {
+  if (context2.mode === "trigger") {
     const client = createClient(
-      resolveRobotRockConfig(context.app ? { app: context.app } : void 0)
+      resolveRobotRockConfig(context2.app ? { app: context2.app } : void 0)
     );
     return client.sendUpdate(payload);
   }
-  return context.client.sendUpdate(payload);
+  return context2.client.sendUpdate(payload);
 }
-async function approveByHumanForAi(context, payload) {
-  if (context.mode === "trigger") {
+async function approveByHumanForAi(context2, payload) {
+  if (context2.mode === "trigger") {
     const { approveByHumanTask: approveByHumanTask2 } = await Promise.resolve().then(() => (init_trigger(), trigger_exports));
     const waitResult = await approveByHumanTask2.triggerAndWait({
       ...payload,
-      ...context.app ? { app: context.app } : {}
+      ...context2.app ? { app: context2.app } : {}
     });
     if (!waitResult.ok) {
       throw waitResult.error;
     }
     return waitResult.output;
   }
-  if (context.mode === "workflow") {
+  if (context2.mode === "workflow") {
     const { approveByHumanInWorkflow: approveByHumanInWorkflow2 } = await Promise.resolve().then(() => (init_workflow(), workflow_exports));
     return await approveByHumanInWorkflow2({
       ...payload,
-      ...context.app ? { app: context.app } : {}
+      ...context2.app ? { app: context2.app } : {}
     });
   }
-  const result = await context.client.sendToHuman({
+  const result = await context2.client.sendToHuman({
     ...payload,
     actions: APPROVE_BY_HUMAN_ACTIONS3
   });
@@ -1596,17 +1798,17 @@ function createSendUpdateTool(clientOrOptions, maybeOptions = {}) {
   return buildSendUpdateToolDefinition(clientOrOptions, maybeOptions);
 }
 function createRobotRockAiTools(options = {}) {
-  const context = { mode: "workflow", app: options.app };
+  const context2 = { mode: "workflow", app: options.app };
   return {
-    context,
-    approveByHuman: (toolOptions) => buildApproveByHumanToolDefinition({ ...context, ...toolOptions }),
+    context: context2,
+    approveByHuman: (toolOptions) => buildApproveByHumanToolDefinition({ ...context2, ...toolOptions }),
     sendToHuman: (toolOptions) => buildSendToHumanToolDefinition({
-      ...context,
+      ...context2,
       ...options.threadId ? { threadId: options.threadId } : {},
       ...toolOptions
     }),
     sendUpdate: (toolOptions = {}) => buildSendUpdateToolDefinition({
-      ...context,
+      ...context2,
       ...options.threadId ? { threadId: options.threadId } : {},
       ...toolOptions
     })
@@ -1617,12 +1819,6 @@ function createRobotRockAiTools(options = {}) {
 function defaultFormatToolApprovalTask(toolCall, options = {}) {
   const approveId = options.approveActionId ?? "approve";
   const denyId = options.denyActionId ?? "deny";
-  let inputPreview;
-  try {
-    inputPreview = JSON.stringify(toolCall.input, null, 2);
-  } catch {
-    inputPreview = String(toolCall.input);
-  }
   return {
     type: options.type ?? "ai-tool-approval",
     name: `Approve: ${toolCall.toolName}`,
@@ -1820,7 +2016,7 @@ function resolveToolCallForRequest(request, source, messages) {
   );
 }
 async function resolveToolApprovalsViaRobotRock(clientOrContext, source, options = {}) {
-  const context = normalizeRobotRockAiContext(clientOrContext);
+  const context2 = normalizeRobotRockAiContext(clientOrContext);
   const approveId = options.approveActionId ?? "approve";
   const denyId = options.denyActionId ?? "deny";
   const formatTask = options.formatTask ?? defaultFormatToolApprovalTask;
@@ -1833,7 +2029,7 @@ async function resolveToolApprovalsViaRobotRock(clientOrContext, source, options
       approveActionId: approveId,
       denyActionId: denyId
     });
-    const result = await sendToHumanForAi(context, taskInput);
+    const result = await sendToHumanForAi(context2, taskInput);
     const approved = result.actionId === approveId;
     const reason = typeof result.data === "object" && result.data !== null && "reason" in result.data && typeof result.data.reason === "string" ? result.data.reason : approved ? "Approved in RobotRock inbox" : "Denied in RobotRock inbox";
     responses.push({