robotrock 0.8.3 → 0.8.5

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, 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, agentTelemetrySchema, agentToolCallsSchema, 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.
@@ -31,6 +32,72 @@ declare function toDiscriminatedApprovalResult<A extends readonly {
     schema?: unknown;
 }[]>(actions: A, task: Task): DiscriminatedApprovalResult<A>;
 
+/**
+ * Reserved inbox actions that reviewers can take outside your task's defined actions.
+ * Agents and integrations must treat these as terminal — stop the run and do not retry sendToHuman.
+ */
+declare const PLATFORM_MARK_DONE_ACTION_ID: "robotrock:mark-done";
+declare const PLATFORM_REJECT_REQUEST_ACTION_ID: "robotrock:reject-request";
+declare const PLATFORM_MARK_DONE_ACTION_TITLE = "Mark as done";
+declare const PLATFORM_REJECT_REQUEST_ACTION_TITLE = "Reject request";
+declare const PLATFORM_TERMINAL_ACTION_IDS: readonly ["robotrock:mark-done", "robotrock:reject-request"];
+type PlatformTerminalActionId = (typeof PLATFORM_TERMINAL_ACTION_IDS)[number];
+type PlatformRejectRequestData = {
+    feedback: string;
+};
+type HandledActionInput = {
+    actionId: string;
+    data?: unknown;
+    handledBy?: string;
+    handledAt?: number | Date;
+};
+type PlatformMarkDoneOutcome = {
+    source: "platform";
+    kind: "mark-done";
+    actionId: typeof PLATFORM_MARK_DONE_ACTION_ID;
+    data: Record<string, never>;
+    handledBy?: string;
+    handledAt?: Date;
+};
+type PlatformRejectRequestOutcome = {
+    source: "platform";
+    kind: "reject-request";
+    actionId: typeof PLATFORM_REJECT_REQUEST_ACTION_ID;
+    data: PlatformRejectRequestData;
+    handledBy?: string;
+    handledAt?: Date;
+};
+type TaskActionOutcome = {
+    source: "task";
+    actionId: string;
+    data: unknown;
+    handledBy?: string;
+    handledAt?: Date;
+};
+type HandledOutcome = PlatformMarkDoneOutcome | PlatformRejectRequestOutcome | TaskActionOutcome;
+declare class PlatformRejectRequestError extends Error {
+    readonly actionId: "robotrock:reject-request";
+    readonly feedback: string;
+    constructor(feedback: string, message?: string);
+}
+declare function isPlatformMarkDoneAction(actionId: string | undefined): actionId is typeof PLATFORM_MARK_DONE_ACTION_ID;
+declare function isPlatformRejectRequestAction(actionId: string | undefined): actionId is typeof PLATFORM_REJECT_REQUEST_ACTION_ID;
+declare function isPlatformTerminalAction(actionId: string | undefined): actionId is PlatformTerminalActionId;
+declare function parsePlatformRejectRequestData(data: unknown): PlatformRejectRequestData | null;
+/**
+ * Classify a handled task action as a platform terminal outcome or a normal task action.
+ */
+declare function parseHandledOutcome(input: HandledActionInput): HandledOutcome;
+/**
+ * Throw when a human rejected the request from the inbox (not your task's reject action).
+ * Use after polling, webhooks, or getTask when you want agents to stop immediately.
+ */
+declare function assertNotPlatformRejectRequest(actionId: string, data?: unknown): void;
+/**
+ * Returns true when the agent should stop — platform mark-done or reject-request.
+ */
+declare function shouldStopAgentForHandledAction(actionId: string | undefined): boolean;
+
 declare const robotRockWebhookPayloadSchema: z.ZodObject<{
     taskId: z.ZodString;
     action: z.ZodObject<{
@@ -70,4 +137,4 @@ interface VerifyRobotRockWebhookOptions {
  */
 declare function verifyRobotRockWebhook(request: Request, options?: VerifyRobotRockWebhookOptions): Promise<RobotRockWebhookPayload>;
 
-export { DiscriminatedApprovalResult, RobotRock, RobotRockConfig, RobotRockWebhookError, type RobotRockWebhookErrorCode, type RobotRockWebhookPayload, Task, TaskExpiredError, TaskTimeoutError, type VerifyRobotRockWebhookOptions, resolveRobotRockClient, resolveRobotRockConfig, toDiscriminatedApprovalResult, verifyRobotRockWebhook };
+export { DiscriminatedApprovalResult, type HandledActionInput, type HandledOutcome, PLATFORM_MARK_DONE_ACTION_ID, PLATFORM_MARK_DONE_ACTION_TITLE, PLATFORM_REJECT_REQUEST_ACTION_ID, PLATFORM_REJECT_REQUEST_ACTION_TITLE, PLATFORM_TERMINAL_ACTION_IDS, type PlatformMarkDoneOutcome, type PlatformRejectRequestData, PlatformRejectRequestError, type PlatformRejectRequestOutcome, type PlatformTerminalActionId, RobotRock, RobotRockConfig, RobotRockWebhookError, type RobotRockWebhookErrorCode, type RobotRockWebhookPayload, Task, type TaskActionOutcome, TaskExpiredError, TaskTimeoutError, type VerifyRobotRockWebhookOptions, assertNotPlatformRejectRequest, isPlatformMarkDoneAction, isPlatformRejectRequestAction, isPlatformTerminalAction, parseHandledOutcome, parsePlatformRejectRequestData, resolveRobotRockClient, resolveRobotRockConfig, shouldStopAgentForHandledAction, toDiscriminatedApprovalResult, verifyRobotRockWebhook };

package/dist/index.js

@@ -291,7 +291,20 @@ var agentCostSchema = z.object({
 });
 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(),
@@ -301,7 +314,9 @@ var agentTelemetrySchema = z.object({
   toolCalls: agentToolCallsSchema.optional(),
   cost: agentCostSchema.optional(),
   /** Free-form metadata for experiments (model, prompt variant, etc.). */
-  info: z.record(z.string(), z.unknown()).optional()
+  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) : [];
@@ -455,13 +470,27 @@ var agentCostSchema2 = z2.object({
 });
 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()
+  info: z2.record(z2.string(), z2.unknown()).optional(),
+  otel: agentOtelSchema2.optional()
 }).refine(
   (data) => {
     const keys = data.info ? Object.keys(data.info) : [];
@@ -856,6 +885,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";
@@ -961,10 +1081,125 @@ 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,
+  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,
@@ -973,14 +1208,25 @@ export {
   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,
   createClient,
   createTaskBodySchema2 as createTaskBodySchema,
+  isPlatformMarkDoneAction,
+  isPlatformRejectRequestAction,
+  isPlatformTerminalAction,
+  parseHandledOutcome,
+  parsePlatformRejectRequestData,
   resolveRobotRockClient,
   resolveRobotRockConfig,
+  shouldStopAgentForHandledAction,
   taskContextSchema2 as taskContextSchema,
   taskPriorities2 as taskPriorities,
   taskPrioritySchema2 as taskPrioritySchema,
@@ -989,6 +1235,7 @@ export {
   threadUpdateStatusSchema2 as threadUpdateStatusSchema,
   threadUpdateStatuses2 as threadUpdateStatuses,
   toDiscriminatedApprovalResult,
+  toolCallsFromOtelSpans,
   verifyRobotRockWebhook
 };
 //# sourceMappingURL=index.js.map