robotrock 0.8.5 → 1.0.0

package/dist/client-CzVmjXpz.d.ts

@@ -0,0 +1,219 @@
+import { TaskContextInput, AssignToInput as AssignToInput$1, TaskPriority, ThreadUpdateStatus, TaskResponse, Task, ThreadUpdate, TaskContextFormatVersion, DiscriminatedApprovalResult } from './schemas/index.js';
+import { AssignToInput, AgentChatSeedMessage } from '@robotrock/core';
+
+/** A chat created via {@link ChatsApi.create}. */
+type CreatedChat = {
+    chatId: string;
+    sessionId: string;
+    userId?: string;
+    agentIdentifier: string;
+    deepLink: string;
+};
+type CreateChatResult = {
+    tenantSlug: string;
+    chats: CreatedChat[];
+};
+type CreateChatInput = {
+    /** Agent to run the chat. Required unless `parentChatId` is provided. */
+    agentIdentifier?: string;
+    /** Spawn a chat from an existing chat; inherits its agent/app/owner and links audit. */
+    parentChatId?: string;
+    /** Trigger connection id to run the chat under (defaults to the tenant's). */
+    connectionId?: string;
+    /** Inbox app bucket. Overrides the client `app` when set. */
+    app?: string;
+    /** Assign to tenant users (email) and/or groups (slug). Narrows inbox visibility. */
+    assignTo?: AssignToInput;
+    /** Chat title shown in the inbox. */
+    title: string;
+    /** Seed messages to preload the conversation. Defaults to a welcome message. */
+    messages?: AgentChatSeedMessage[];
+    /** How the chat was created (statistics/audit). @default "api" */
+    source?: string;
+};
+type CloseChatOptions = {
+    /** Optional human-readable reason recorded on the audit trail. */
+    reason?: string;
+};
+interface ChatsApi {
+    /** Create one or more agent chats and assign them (task-style). */
+    create(input: CreateChatInput): Promise<CreateChatResult>;
+    /** Close (archive) a chat by its public chatId — e.g. when an agent is done. */
+    close(chatId: string, options?: CloseChatOptions): Promise<void>;
+}
+/**
+ * Build the `client.chats` namespace. Mirrors the `client.tasks` surface for the
+ * long-lived chat resource, so a single client creates both tasks and chats.
+ */
+declare function createChatsApi(config: {
+    baseUrl: string;
+    apiKey: string;
+    app?: string;
+}): ChatsApi;
+
+type RobotRockWebhookConfig = {
+    url: string;
+    headers?: Record<string, string>;
+};
+interface RobotRockPollingOptions {
+    /** Poll interval when no webhook is configured (ms). @default 2000 */
+    intervalMs?: number;
+    /**
+     * Max time to poll when no webhook is configured (ms).
+     * Polling also stops when the task's `validUntil` passes, whichever is sooner.
+     * @default 86400000 (24h)
+     */
+    timeoutMs?: number;
+}
+/** Advanced client settings rarely changed by integrators. */
+type RobotRockAdvancedConfig = {
+    /** Task context wire format version sent on every request. @default 2 */
+    contextVersion?: TaskContextFormatVersion;
+};
+type RobotRockClientBaseConfig = {
+    /** Optional override for API key. Falls back to ROBOTROCK_API_KEY. */
+    apiKey?: string;
+    /**
+     * Base URL for the RobotRock API
+     * @default "https://api.robotrock.io/v1"
+     */
+    baseUrl?: string;
+    /**
+     * Default inbox app bucket for every task from this client.
+     * When omitted, the API uses your API key name.
+     */
+    app?: string;
+    /**
+     * Agent release version (semver, git SHA, deploy tag).
+     * Defaults to `AGENT_VERSION` or `ROBOTROCK_AGENT_VERSION` from env when omitted.
+     */
+    version?: string;
+    /** Advanced settings (context wire format, etc.). */
+    advanced?: RobotRockAdvancedConfig;
+};
+/** Client config with a webhook (mutually exclusive with `polling`). */
+type RobotRockWebhookClientConfig = RobotRockClientBaseConfig & {
+    webhook: RobotRockWebhookConfig;
+    polling?: never;
+};
+/** Client config without a webhook; optional `polling` controls the wait loop. */
+type RobotRockPollingClientConfig = RobotRockClientBaseConfig & {
+    webhook?: never;
+    polling?: RobotRockPollingOptions;
+};
+type RobotRockConfig = RobotRockWebhookClientConfig | RobotRockPollingClientConfig;
+type SendToHumanActionInput = Omit<TaskContextInput["actions"][number], "handlers">;
+type SendToHumanValidUntil = Date | string;
+type SendToHumanInput<A extends readonly SendToHumanActionInput[] = readonly SendToHumanActionInput[]> = Omit<TaskContextInput, "app" | "actions" | "contextVersion" | "version" | "validUntil"> & {
+    actions: A;
+    /** Task deadline; serialized to an ISO 8601 string on the wire. */
+    validUntil?: SendToHumanValidUntil;
+    /** Optional idempotency key to prevent duplicate tasks */
+    idempotencyKey?: string;
+    /** Assign to tenant users (email) and/or groups (slug). Narrows inbox visibility. */
+    assignTo?: AssignToInput$1;
+    /**
+     * Groups related tasks together in the inbox. Omit to let the server generate
+     * one (returned as `task.threadId`) and reuse it on later tasks in the thread.
+     */
+    threadId?: string;
+    /**
+     * Optional thread priority. When set, applies to the whole thread and
+     * overwrites any previous priority. Omit on later tasks to leave unchanged.
+     */
+    priority?: TaskPriority;
+    /**
+     * Optional initial status update logged against the task's thread. Shows in
+     * the inbox status bar and the thread update log.
+     */
+    update?: {
+        /** A short status update (1-2 sentences). */
+        message: string;
+        /** Lifecycle status for the icon/color in the status bar. @default "info" */
+        status?: ThreadUpdateStatus;
+    };
+    /**
+     * Agent release version override. When omitted, uses the client `version`.
+     * Used for statistics and feedback analysis.
+     */
+    version?: string;
+};
+type SendToHumanWithAppInput<A extends readonly SendToHumanActionInput[] = readonly SendToHumanActionInput[]> = (SendToHumanInput<A> | Readonly<SendToHumanInput<A>>) & {
+    /** Inbox app bucket. Overrides the client `app` when set. */
+    app?: string;
+};
+type SendUpdateInput = {
+    /** The thread to log the update against (from `task.threadId`). */
+    threadId: string;
+    /** A short status update (1-2 sentences). */
+    message: string;
+    /** Lifecycle status for the icon/color in the status bar. @default "info" */
+    status?: ThreadUpdateStatus;
+};
+type SendToHumanResult<A extends readonly SendToHumanActionInput[] = readonly SendToHumanActionInput[]> = {
+    mode: "created";
+    task: TaskResponse["task"];
+} | ({
+    mode: "handled";
+    task: TaskResponse["task"];
+} & DiscriminatedApprovalResult<A>);
+
+/** Task CRUD surface, exposed as `client.tasks`. */
+interface TasksApi {
+    /** Create a task via POST /v1 without waiting for a human response. */
+    create<const A extends readonly SendToHumanActionInput[]>(task: SendToHumanWithAppInput<A>): Promise<TaskResponse["task"]>;
+    /** Get a task by public task id. */
+    get(taskId: string): Promise<Task | null>;
+    /** Cancel a task by public task id. */
+    cancel(taskId: string): Promise<void>;
+    /** Log a status update against a thread. */
+    sendUpdate(input: SendUpdateInput): Promise<ThreadUpdate>;
+}
+/**
+ * RobotRock API client for creating and querying human-in-the-loop tasks and
+ * chats. CRUD lives under `client.tasks` and `client.chats`; the headline
+ * `sendToHuman` verb stays top-level.
+ */
+declare class RobotRock {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly app?;
+    private readonly agentVersion?;
+    private readonly contextVersion;
+    private readonly webhook?;
+    private readonly polling;
+    /** Task CRUD: `create`, `get`, `cancel`, `sendUpdate`. */
+    readonly tasks: TasksApi;
+    /** Chat CRUD: `create`, `close`. */
+    readonly chats: ChatsApi;
+    constructor(config: RobotRockConfig);
+    private createTaskRequest;
+    sendToHuman<const A extends readonly SendToHumanActionInput[]>(task: SendToHumanWithAppInput<A>): Promise<SendToHumanResult<A>>;
+    /**
+     * Create a task via POST /v1 without waiting for a human response.
+     * @deprecated Use `client.tasks.create()` instead.
+     */
+    createTask<const A extends readonly SendToHumanActionInput[]>(task: SendToHumanWithAppInput<A>): Promise<TaskResponse["task"]>;
+    /**
+     * Get a task by public task id (returned as `task.taskId` from {@link sendToHuman}).
+     * @deprecated Use `client.tasks.get()` instead.
+     */
+    getTask(taskId: string): Promise<Task | null>;
+    /**
+     * Log a status update against a thread.
+     * @deprecated Use `client.tasks.sendUpdate()` instead.
+     */
+    sendUpdate(input: SendUpdateInput): Promise<ThreadUpdate>;
+    /**
+     * Cancel a task by public task id.
+     * @deprecated Use `client.tasks.cancel()` instead.
+     */
+    cancelTask(taskId: string): Promise<void>;
+    private getTaskById;
+    private sendThreadUpdate;
+    private cancelTaskRequest;
+}
+declare function createClient(config: RobotRockConfig): RobotRock;
+declare function attachWebhookToActions(actions: readonly SendToHumanActionInput[], webhook: RobotRockWebhookConfig): TaskContextInput["actions"];
+
+export { type ChatsApi as C, RobotRock as R, type SendToHumanActionInput as S, type TasksApi as T, type SendToHumanInput as a, type RobotRockConfig as b, type CloseChatOptions as c, type CreateChatInput as d, type CreateChatResult as e, type CreatedChat as f, type RobotRockAdvancedConfig as g, type RobotRockPollingClientConfig as h, type RobotRockPollingOptions as i, type RobotRockWebhookClientConfig as j, type RobotRockWebhookConfig as k, type SendToHumanResult as l, type SendToHumanValidUntil as m, type SendUpdateInput as n, attachWebhookToActions as o, createChatsApi as p, createClient as q };

package/dist/index.d.ts

@@ -1,10 +1,17 @@
-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 { R as RobotRock, b as RobotRockConfig } from './client-CzVmjXpz.js';
+export { C as ChatsApi, c as CloseChatOptions, d as CreateChatInput, e as CreateChatResult, f as CreatedChat, g as RobotRockAdvancedConfig, h as RobotRockPollingClientConfig, i as RobotRockPollingOptions, j as RobotRockWebhookClientConfig, k as RobotRockWebhookConfig, S as SendToHumanActionInput, a as SendToHumanInput, l as SendToHumanResult, m as SendToHumanValidUntil, n as SendUpdateInput, T as TasksApi, o as attachWebhookToActions, p as createChatsApi, q as createClient } from './client-CzVmjXpz.js';
+export { AgentChatSeedMessage, CreateAgentChatBody, CreateAgentChatBodyInput, agentChatSeedMessageSchema, createAgentChatBodySchema } from '@robotrock/core';
 import { Task, DiscriminatedApprovalResult } 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';
+export { AgentTelemetry, AgentTelemetryInput, ApprovalResult, AssignToInput, CreateTaskBody, CreateTaskBodyInput, DEFAULT_TASK_PRIORITY, DEFAULT_THREAD_UPDATE_STATUS, Handler, InferActionData, LOWEST_TASK_PRIORITY, TASK_CONTEXT_FORMAT_VERSION, TASK_PRIORITY_RANK, TaskAction, TaskContext, TaskContextFormatVersion, TaskContextInput, TaskPriority, TaskResponse, TaskResult, TaskStatus, ThreadUpdate, ThreadUpdateBody, ThreadUpdateBodyInput, ThreadUpdateInput, ThreadUpdateResponse, ThreadUpdateSource, ThreadUpdateStatus, TriggerHandler, TupleElementIndices, WebhookHandler, agentTelemetrySchema, 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';
+export { E as EndRobotRockHumanWaitSpanOptions, b as RobotRockCreatedTask, c as RobotRockHandledOtelInput, a as RobotRockHandlerWebhookPayload, d as RobotRockHumanWaitOtelSession, e as RobotRockOtelHandle, f as RobotRockOtelRecordOptions, R as RobotRockPlatformOtelFields, g as beginRobotRockHumanWaitOtel, h as captureRobotRockOtelHandle, i as endRobotRockHumanWaitSpan, j as finishRobotRockHumanWaitOtel, r as recordRobotRockHandledToOtel, s as shouldRecordRobotRockOtel, k as startRobotRockHumanWaitSpan, l as stripPlatformOtelFields, t as toRobotRockHandledOtelInput } from './otel-platform-DzHyHkGk.js';
+import '@opentelemetry/api';
+
+declare class RobotRockError extends Error {
+    readonly statusCode: number;
+    readonly response?: unknown | undefined;
+    constructor(message: string, statusCode: number, response?: unknown | undefined);
+}
 
 /**
  * Read RobotRock client config from environment variables.
@@ -98,7 +105,7 @@ declare function assertNotPlatformRejectRequest(actionId: string, data?: unknown
  */
 declare function shouldStopAgentForHandledAction(actionId: string | undefined): boolean;
 
-declare const robotRockWebhookPayloadSchema: z.ZodObject<{
+declare const robotRockWebhookPayloadBodySchema: z.ZodObject<{
     taskId: z.ZodString;
     action: z.ZodObject<{
         id: z.ZodString;
@@ -108,15 +115,16 @@ declare const robotRockWebhookPayloadSchema: z.ZodObject<{
     handledBy: z.ZodOptional<z.ZodString>;
     handledAt: z.ZodString;
     handlerType: z.ZodString;
-    headers: z.ZodRecord<z.ZodString, z.ZodString>;
 }, z.core.$strip>;
+type RobotRockWebhookPayload = z.infer<typeof robotRockWebhookPayloadBodySchema> & {
+    headers: Record<string, string>;
+};
 type RobotRockWebhookErrorCode = "MISSING_WEBHOOK_SECRET" | "MISSING_SIGNATURE" | "INVALID_SIGNATURE" | "INVALID_JSON" | "INVALID_PAYLOAD";
 declare class RobotRockWebhookError extends Error {
     readonly code: RobotRockWebhookErrorCode;
     readonly details?: unknown | undefined;
     constructor(message: string, code: RobotRockWebhookErrorCode, details?: unknown | undefined);
 }
-type RobotRockWebhookPayload = z.infer<typeof robotRockWebhookPayloadSchema>;
 interface VerifyRobotRockWebhookOptions {
     /**
      * Override shared secret (defaults to ROBOTROCK_WEBHOOK_SECRET).
@@ -137,4 +145,4 @@ interface VerifyRobotRockWebhookOptions {
  */
 declare function verifyRobotRockWebhook(request: Request, options?: VerifyRobotRockWebhookOptions): Promise<RobotRockWebhookPayload>;
 
-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 };
+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, RobotRockError, RobotRockWebhookError, type RobotRockWebhookErrorCode, type RobotRockWebhookPayload, Task, type TaskActionOutcome, TaskExpiredError, TaskTimeoutError, type VerifyRobotRockWebhookOptions, assertNotPlatformRejectRequest, isPlatformMarkDoneAction, isPlatformRejectRequestAction, isPlatformTerminalAction, parseHandledOutcome, parsePlatformRejectRequestData, resolveRobotRockClient, resolveRobotRockConfig, shouldStopAgentForHandledAction, toDiscriminatedApprovalResult, verifyRobotRockWebhook };