robotrock 1.0.0 → 1.1.0

package/dist/{client-CzVmjXpz.d.ts → client-XTnFHGFE.d.ts}

@@ -1,5 +1,15 @@
 import { TaskContextInput, AssignToInput as AssignToInput$1, TaskPriority, ThreadUpdateStatus, TaskResponse, Task, ThreadUpdate, TaskContextFormatVersion, DiscriminatedApprovalResult } from './schemas/index.js';
-import { AssignToInput, AgentChatSeedMessage } from '@robotrock/core';
+import { AssignToInput, AgentChatSeedMessage, AgentChatStageHitlBody, AgentChatAuditInputBody, AgentChatLinkTaskBody } from '@robotrock/core';
+
+type RobotRockAuthConfig = {
+    kind: "apiKey";
+    apiKey: string;
+} | {
+    kind: "agentService";
+    token: string;
+    tenantSlug: string;
+    connectionId: string;
+};
 
 /** A chat created via {@link ChatsApi.create}. */
 type CreatedChat = {
@@ -35,11 +45,23 @@ type CloseChatOptions = {
     /** Optional human-readable reason recorded on the audit trail. */
     reason?: string;
 };
+type LogChatInputSubmissionInput = AgentChatAuditInputBody;
+type StageChatHitlRequestsInput = AgentChatStageHitlBody;
+type LinkChatTaskInput = AgentChatLinkTaskBody;
+type StagedChatHitlRequest = StageChatHitlRequestsInput["requests"][number];
 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>;
+    /** Persist pending Eve HITL requests on the chat for durable audit logging. */
+    stageHitlRequests(input: StageChatHitlRequestsInput): Promise<void>;
+    /** Read pending Eve HITL requests staged on the chat. */
+    getStagedHitlRequests(eveSessionId: string): Promise<StagedChatHitlRequest[]>;
+    /** Log an Eve HITL choice to the RobotRock chat audit trail. */
+    logInputSubmission(input: LogChatInputSubmissionInput): Promise<void>;
+    /** Link an inbox task to the originating Eve chat session. */
+    linkTask(input: LinkChatTaskInput): Promise<void>;
 }
 /**
  * Build the `client.chats` namespace. Mirrors the `client.tasks` surface for the
@@ -47,7 +69,7 @@ interface ChatsApi {
  */
 declare function createChatsApi(config: {
     baseUrl: string;
-    apiKey: string;
+    auth: RobotRockAuthConfig;
     app?: string;
 }): ChatsApi;
 
@@ -71,8 +93,14 @@ type RobotRockAdvancedConfig = {
     contextVersion?: TaskContextFormatVersion;
 };
 type RobotRockClientBaseConfig = {
-    /** Optional override for API key. Falls back to ROBOTROCK_API_KEY. */
+    /** Optional override for API key. Falls back to ROBOTROCK_API_KEY when agentService is unset. */
     apiKey?: string;
+    /** Hosted-agent service auth (mutually exclusive with apiKey). */
+    agentService?: {
+        token: string;
+        tenantSlug: string;
+        connectionId: string;
+    };
     /**
      * Base URL for the RobotRock API
      * @default "https://api.robotrock.io/v1"
@@ -175,7 +203,7 @@ interface TasksApi {
  * `sendToHuman` verb stays top-level.
  */
 declare class RobotRock {
-    private readonly apiKey;
+    private readonly auth;
     private readonly baseUrl;
     private readonly app?;
     private readonly agentVersion?;
@@ -187,6 +215,7 @@ declare class RobotRock {
     /** Chat CRUD: `create`, `close`. */
     readonly chats: ChatsApi;
     constructor(config: RobotRockConfig);
+    private authHeaders;
     private createTaskRequest;
     sendToHuman<const A extends readonly SendToHumanActionInput[]>(task: SendToHumanWithAppInput<A>): Promise<SendToHumanResult<A>>;
     /**
@@ -216,4 +245,4 @@ declare class RobotRock {
 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 };
+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, type StageChatHitlRequestsInput as o, type StagedChatHitlRequest as p, attachWebhookToActions as q, createChatsApi as r, createClient as s };

package/dist/eve/agent/index.d.ts

@@ -0,0 +1,188 @@
+export { a as TenantCaller, T as TenantRole, i as isAdminCaller, r as requireAdminCaller, b as requireTenantCaller, t as tryResolveTenantCaller } from '../../tenant-5YKDrdC-.js';
+import { AuthFn, vercelOidc } from 'eve/channels/auth';
+import * as eve_channels_eve from 'eve/channels/eve';
+import { R as RobotRock, p as StagedChatHitlRequest, a as SendToHumanInput, S as SendToHumanActionInput, e as CreateChatResult } from '../../client-XTnFHGFE.js';
+import { SessionContext } from 'eve/context';
+import { TaskPriority } from '../../schemas/index.js';
+import * as node_modules_eve_dist_src_protocol_message_js from 'node_modules/eve/dist/src/protocol/message.js';
+import { HookContext } from 'eve/hooks';
+export { ROBOTROCK_PLATFORM_USER_CONTEXT_PUBLIC_KEY_URL } from '@robotrock/core/eve/platform-user-context-public-key';
+export { R as ROBOTROCK_READY_HOOK_SLUG } from '../../index-BL9qKHA8.js';
+export { ROBOTROCK_USER_CONTEXT_AUDIENCE, ROBOTROCK_USER_CONTEXT_ISSUER } from '@robotrock/core/eve/user-context-jwt';
+import '@robotrock/core';
+import 'zod';
+
+/** Header carrying the dashboard user-context JWT on proxied Eve requests. */
+declare const ROBOTROCK_USER_CONTEXT_HEADER = "x-robotrock-user-token";
+
+type RobotrockUserContextAuthOptions = {
+    publicKeyPem?: string | (() => Promise<string | null>);
+    hmacSecret?: string;
+};
+/**
+ * Verifies the short-lived user-context JWT minted by the RobotRock dashboard
+ * Eve proxy (`X-RobotRock-User-Token`). Hosted tenants use RS256 platform JWTs;
+ * self-hosted deployments use per-connection HMAC secrets.
+ */
+declare function robotrockUserContextAuth(options?: RobotrockUserContextAuthOptions): AuthFn<Request>;
+/**
+ * Bearer `ras_*` service token for RobotRock platform reachability probes
+ * (`GET /eve/v1/info` during verify and tenant connect).
+ */
+declare function robotrockAgentServiceAuth(): AuthFn<Request>;
+/** Bearer token used by the RobotRock webhook resume self-call. */
+declare function eveSelfServiceAuth(): AuthFn<Request>;
+
+/** Resolve the platform RS256 public key used to verify dashboard user-context JWTs. */
+declare function resolvePlatformUserContextPublicKeyPem(): Promise<string | null>;
+
+type RobotrockEveChannelOptions = {
+    /** Your existing webapp auth — stacked after RobotRock user-context auth. */
+    auth?: AuthFn<Request>[];
+    /** Include RobotRock user-context + service auth. @default true */
+    robotrock?: boolean;
+    /** Include localDev() fallback. @default true when NODE_ENV !== "production" */
+    localDev?: boolean;
+    /** Optional Vercel OIDC allowlist (dashboard ↔ agent on Vercel). */
+    vercelOidc?: Parameters<typeof vercelOidc>[0] | false;
+    /** Options passed to robotrockUserContextAuth when robotrock is enabled. */
+    userContextAuth?: RobotrockUserContextAuthOptions;
+};
+/**
+ * Compose the default Eve HTTP channel with RobotRock dashboard auth stacked
+ * alongside optional existing webapp authenticators.
+ */
+declare function robotrockEveChannel(options?: RobotrockEveChannelOptions): eve_channels_eve.EveChannel;
+
+/** Create a RobotRock client bound to the current Eve session tenant context. */
+declare function tryCreateBoundRobotRockClient(ctx: SessionContext): RobotRock | null;
+/** Reset missing-auth warning (tests only). */
+declare function resetBoundClientAuthWarning(): void;
+
+type RobotRockChatAuditPayload = {
+    eveSessionId: string;
+    userId: string;
+    actionId: string;
+    actionTitle?: string;
+    prompt?: string;
+    data?: Record<string, unknown>;
+    idempotencyKey?: string;
+    requestId?: string;
+    toolCallId?: string;
+};
+/** Observe-only audit POST — never throws. */
+declare function postRobotRockChatInputAudit(ctx: SessionContext, payload: RobotRockChatAuditPayload): Promise<void>;
+/** Persist pending HITL requests across Eve durable waits — never throws. */
+declare function postRobotRockStageHitl(ctx: SessionContext, input: {
+    eveSessionId: string;
+    requests: StagedChatHitlRequest[];
+}): Promise<void>;
+/** Load staged HITL requests from Convex — returns [] on failure. */
+declare function fetchRobotRockStagedHitl(ctx: SessionContext, eveSessionId: string): Promise<StagedChatHitlRequest[]>;
+/** Register an inbox task with its originating Eve chat session — never throws. */
+declare function postRobotRockLinkChatTask(ctx: SessionContext, input: {
+    eveSessionId: string;
+    publicTaskId: string;
+    toolCallId: string;
+}): Promise<void>;
+/** Reset audit warning flags (tests only). */
+declare function resetChatAuditWarnings(): void;
+
+type CreateRobotRockTaskInput = SendToHumanInput<readonly SendToHumanActionInput[]> & {
+    app?: string;
+};
+/** Resolve the webhook URL RobotRock calls when a delegated inbox task is handled. */
+declare function resolveTaskHandledWebhookUrl(baseUrl: string): string;
+/** Create an inbox task via POST /v1 without waiting for a human response. */
+declare function createRobotRockTask(input: CreateRobotRockTaskInput, ctx: SessionContext): Promise<{
+    taskId: string;
+    threadId: string;
+    status: "pending" | "open";
+    validUntil: string;
+    submittedAt: string;
+}>;
+type RobotRockTaskActionInput = {
+    id: string;
+    title: string;
+    description?: string;
+};
+type RobotRockTaskAssignToInput = {
+    users?: string[];
+    groups?: string[];
+};
+type RobotRockTaskContextInput = {
+    data?: Record<string, unknown>;
+    ui?: Record<string, unknown>;
+};
+type RobotRockTaskToolInput = {
+    type: string;
+    name: string;
+    description?: string;
+    actions: RobotRockTaskActionInput[];
+    assignTo?: RobotRockTaskAssignToInput;
+    context?: RobotRockTaskContextInput;
+    validUntilHours?: number;
+    priority?: TaskPriority;
+    updateMessage?: string;
+    app?: string;
+};
+declare function buildRobotRockTaskPayload(input: RobotRockTaskToolInput, options?: {
+    requestedByEmail?: string;
+}): CreateRobotRockTaskInput;
+
+type CreateRobotRockCronChatInput = {
+    title: string;
+    messages: {
+        role: "user" | "assistant";
+        text: string;
+    }[];
+    agentIdentifier?: string;
+    assignTo?: {
+        users?: string[];
+        groups?: string[];
+    };
+};
+/** Create an inbox chat from an Eve schedule via the RobotRock API. */
+declare function createRobotRockCronChat(input: CreateRobotRockCronChatInput): Promise<CreateChatResult>;
+
+/**
+ * Marker hook for RobotRock dashboard auto-detection.
+ *
+ * RobotRock reads `GET /eve/v1/info` on connect and treats deployments with a
+ * hook slug `robotrock-ready` as RobotRock-ready.
+ */
+declare const robotrockReadyHook: {};
+/** Alias for agents that prefer a factory name. */
+declare function defineRobotRockReadyHook(): {};
+
+/** Reset logged idempotency keys (tests only). */
+declare function resetRobotrockChatAuditIdempotencyKeys(): void;
+declare const robotrockChatAuditHook: {
+    events: {
+        "input.requested"(event: node_modules_eve_dist_src_protocol_message_js.InputRequestedStreamEvent & {
+            readonly meta?: node_modules_eve_dist_src_protocol_message_js.HandleMessageStreamEventMeta;
+        }, ctx: HookContext): Promise<void>;
+        "message.received"(event: node_modules_eve_dist_src_protocol_message_js.MessageReceivedStreamEvent & {
+            readonly meta?: node_modules_eve_dist_src_protocol_message_js.HandleMessageStreamEventMeta;
+        }, ctx: HookContext): Promise<void>;
+        "action.result"(event: node_modules_eve_dist_src_protocol_message_js.ActionResultStreamEvent & {
+            readonly meta?: node_modules_eve_dist_src_protocol_message_js.HandleMessageStreamEventMeta;
+        }, ctx: HookContext): Promise<void>;
+    };
+};
+/** Alias for agents that prefer a factory name. */
+declare function defineRobotRockChatAuditHook(): {
+    events: {
+        "input.requested"(event: node_modules_eve_dist_src_protocol_message_js.InputRequestedStreamEvent & {
+            readonly meta?: node_modules_eve_dist_src_protocol_message_js.HandleMessageStreamEventMeta;
+        }, ctx: HookContext): Promise<void>;
+        "message.received"(event: node_modules_eve_dist_src_protocol_message_js.MessageReceivedStreamEvent & {
+            readonly meta?: node_modules_eve_dist_src_protocol_message_js.HandleMessageStreamEventMeta;
+        }, ctx: HookContext): Promise<void>;
+        "action.result"(event: node_modules_eve_dist_src_protocol_message_js.ActionResultStreamEvent & {
+            readonly meta?: node_modules_eve_dist_src_protocol_message_js.HandleMessageStreamEventMeta;
+        }, ctx: HookContext): Promise<void>;
+    };
+};
+
+export { type CreateRobotRockCronChatInput, type CreateRobotRockTaskInput, ROBOTROCK_USER_CONTEXT_HEADER, type RobotRockChatAuditPayload, type RobotRockTaskActionInput, type RobotRockTaskAssignToInput, type RobotRockTaskContextInput, type RobotRockTaskToolInput, type RobotrockEveChannelOptions, type RobotrockUserContextAuthOptions, buildRobotRockTaskPayload, createRobotRockCronChat, createRobotRockTask, defineRobotRockChatAuditHook, defineRobotRockReadyHook, eveSelfServiceAuth, fetchRobotRockStagedHitl, postRobotRockChatInputAudit, postRobotRockLinkChatTask, postRobotRockStageHitl, resetBoundClientAuthWarning, resetChatAuditWarnings, resetRobotrockChatAuditIdempotencyKeys, resolvePlatformUserContextPublicKeyPem, resolveTaskHandledWebhookUrl, robotrockAgentServiceAuth, robotrockChatAuditHook, robotrockEveChannel, robotrockReadyHook, robotrockUserContextAuth, tryCreateBoundRobotRockClient };