robotrock 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -1,53 +1,104 @@
-import { R as RobotRockConfig, a as RobotRock, C as CreateTaskOptions } from './client-BQ-j7q68.js';
-export { b as RobotRockError, c as createClient } from './client-BQ-j7q68.js';
-import { TaskAction, TaskContextInput, DiscriminatedApprovalResult, Task } from '@robotrock/core';
-export { ApprovalResult, DiscriminatedApprovalResult, Handler, InferActionData, Task, TaskAction, TaskContext, TaskContextInput, TaskResponse, TaskResult, TaskStatus, TriggerHandler, TupleElementIndices, WebhookHandler, taskContextSchema } from '@robotrock/core';
+import { R as RobotRockConfig, b as RobotRock } from './client-Dhk9qxhL.js';
+export { c as RobotRockError, g as RobotRockPollingClientConfig, i as RobotRockPollingOptions, f as RobotRockWebhookClientConfig, h as RobotRockWebhookConfig, S as SendToHumanActionInput, a as SendToHumanInput, k as SendToHumanResult, j as SendToHumanValidUntil, d as attachWebhookToActions, e as createClient } from './client-Dhk9qxhL.js';
+import { Task, DiscriminatedApprovalResult } from './schemas/index.js';
+export { ApprovalResult, AssignToInput, CreateTaskBody, CreateTaskBodyInput, Handler, InferActionData, TaskAction, TaskContext, TaskContextInput, TaskResponse, TaskResult, TaskStatus, TriggerHandler, TupleElementIndices, WebhookHandler, assignToSchema, createTaskBodySchema, taskContextSchema } from './schemas/index.js';
+import { z } from 'zod';
+export { R as RobotRockHandlerWebhookPayload } from './handler-webhook-BqEi6Bk-.js';
 
 /**
  * Read RobotRock client config from environment variables.
  *
  * - `ROBOTROCK_API_KEY` (required when not passed explicitly)
  * - `ROBOTROCK_BASE_URL` or `ROBOTROCK_API_URL` (optional)
+ * - `ROBOTROCK_APP` (optional inbox app bucket)
  */
 declare function resolveRobotRockConfig(overrides?: Partial<RobotRockConfig>): RobotRockConfig;
 /** Use an explicit client or create one from env / optional config overrides. */
 declare function resolveRobotRockClient(client?: RobotRock, configOverrides?: Partial<RobotRockConfig>): RobotRock;
 
-/** Task payload for {@link askHuman}; `actions` must stay a literal tuple for inference. */
-type AskHumanTask<A extends readonly TaskAction[]> = Omit<TaskContextInput, "actions"> & {
-    readonly actions: A;
-};
-type AskHumanParams<A extends readonly TaskAction[]> = {
-    task: AskHumanTask<A>;
-    /** Pre-configured client; when omitted, one is created from env / `apiKey` / `baseUrl`. */
-    client?: RobotRock;
-    apiKey?: string;
-    baseUrl?: string;
-    /** Poll interval while waiting for a human (ms). @default 2000 */
-    pollInterval?: number;
-    /** Max wait time (ms). @default 86400000 (24h) */
-    timeout?: number;
-} & Pick<CreateTaskOptions, "idempotencyKey">;
-/**
- * Create a human-in-the-loop task and block until someone completes it.
- *
- * Uses polling against the RobotRock API. For durable waits inside Trigger.dev,
- * use `robotrock/trigger` instead.
- *
- * The return type is inferred from `task.actions`: `actionId` narrows `data`.
- */
-declare function askHuman<const A extends readonly TaskAction[]>(params: AskHumanParams<A>): Promise<DiscriminatedApprovalResult<A>>;
-
-declare class AskHumanTimeoutError extends Error {
+declare class TaskTimeoutError extends Error {
     constructor(message: string);
 }
-declare class AskHumanExpiredError extends Error {
+declare class TaskExpiredError extends Error {
     constructor(message: string);
 }
 /**
  * Map a handled API task to a discriminated approval result.
  * Runtime validation is minimal; TypeScript narrows via `task.actions` at the call site.
  */
-declare function toDiscriminatedApprovalResult<A extends readonly TaskAction[]>(actions: A, task: Task, streamEntryId: string): DiscriminatedApprovalResult<A>;
+declare function toDiscriminatedApprovalResult<A extends readonly {
+    id: string;
+    schema?: unknown;
+}[]>(actions: A, task: Task): DiscriminatedApprovalResult<A>;
+
+declare const robotRockWebhookPayloadSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    action: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        data: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        title: string;
+        data?: unknown;
+    }, {
+        id: string;
+        title: string;
+        data?: unknown;
+    }>;
+    handledBy: z.ZodOptional<z.ZodString>;
+    handledAt: z.ZodString;
+    handlerType: z.ZodString;
+} & {
+    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    headers: Record<string, string>;
+    taskId: string;
+    handledAt: string;
+    action: {
+        id: string;
+        title: string;
+        data?: unknown;
+    };
+    handlerType: string;
+    handledBy?: string | undefined;
+}, {
+    headers: Record<string, string>;
+    taskId: string;
+    handledAt: string;
+    action: {
+        id: string;
+        title: string;
+        data?: unknown;
+    };
+    handlerType: string;
+    handledBy?: string | undefined;
+}>;
+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).
+     * Keep undefined in production to enforce the canonical env var.
+     */
+    secret?: string;
+    /**
+     * Resolve the tenant signing secret by public task id (hosted MCP uses Convex).
+     * Used when secret is not passed explicitly.
+     */
+    resolveSecret?: (taskId: string) => Promise<string | undefined>;
+    /** Signature header to read. @default "x-robotrock-signature" */
+    signatureHeader?: string;
+}
+/**
+ * Verify a RobotRock webhook request and return a validated payload.
+ * Throws RobotRockWebhookError with machine-readable `code` for audit logging.
+ */
+declare function verifyRobotRockWebhook(request: Request, options?: VerifyRobotRockWebhookOptions): Promise<RobotRockWebhookPayload>;
 
-export { AskHumanExpiredError, type AskHumanParams, type AskHumanTask, AskHumanTimeoutError, CreateTaskOptions, RobotRock, RobotRockConfig, askHuman, resolveRobotRockClient, resolveRobotRockConfig, toDiscriminatedApprovalResult };
+export { DiscriminatedApprovalResult, RobotRock, RobotRockConfig, RobotRockWebhookError, type RobotRockWebhookErrorCode, type RobotRockWebhookPayload, Task, TaskExpiredError, TaskTimeoutError, type VerifyRobotRockWebhookOptions, resolveRobotRockClient, resolveRobotRockConfig, toDiscriminatedApprovalResult, verifyRobotRockWebhook };

package/dist/index.js

@@ -1,60 +1,139 @@
 import {
-  AskHumanExpiredError,
-  AskHumanTimeoutError,
   RobotRock,
   RobotRockError,
+  TaskExpiredError,
+  TaskTimeoutError,
+  attachWebhookToActions,
   createClient,
   resolveRobotRockClient,
   resolveRobotRockConfig,
-  taskContextSchema,
   toDiscriminatedApprovalResult
-} from "./chunk-TUQXDKV6.js";
+} from "./chunk-KOXJCIST.js";
+import {
+  assignToSchema,
+  createTaskBodySchema,
+  taskContextSchema
+} from "./chunk-LXM7VS4Q.js";
 
-// src/ask-human.ts
-var DEFAULT_POLL_INTERVAL_MS = 2e3;
-var DEFAULT_TIMEOUT_MS = 24 * 60 * 60 * 1e3;
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+// src/webhook.ts
+import { createHmac, timingSafeEqual } from "crypto";
+import { z } from "zod";
+var ROBOTROCK_SIGNATURE_HEADER = "x-robotrock-signature";
+var robotRockWebhookPayloadBodySchema = z.object({
+  taskId: z.string().min(1),
+  action: z.object({
+    id: z.string().min(1),
+    title: z.string().min(1),
+    data: z.unknown()
+  }),
+  handledBy: z.string().min(1).optional(),
+  handledAt: z.string().min(1),
+  handlerType: z.string().min(1)
+});
+var robotRockWebhookPayloadSchema = robotRockWebhookPayloadBodySchema.extend({
+  headers: z.record(z.string())
+});
+var RobotRockWebhookError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "RobotRockWebhookError";
+  }
+};
+async function verifyRobotRockWebhook(request, options = {}) {
+  const signatureHeaderName = options.signatureHeader ?? ROBOTROCK_SIGNATURE_HEADER;
+  const signature = request.headers.get(signatureHeaderName);
+  if (!signature) {
+    throw new RobotRockWebhookError(
+      `Missing webhook signature header: ${signatureHeaderName}`,
+      "MISSING_SIGNATURE"
+    );
+  }
+  const rawBody = await request.text();
+  const secret = await resolveWebhookSigningSecret(rawBody, options);
+  if (!secret) {
+    throw new RobotRockWebhookError(
+      "Missing webhook signing secret for verification",
+      "MISSING_WEBHOOK_SECRET"
+    );
+  }
+  assertValidSignature(rawBody, signature, secret);
+  let parsedBody;
+  try {
+    parsedBody = JSON.parse(rawBody);
+  } catch (error) {
+    throw new RobotRockWebhookError("Webhook body is not valid JSON", "INVALID_JSON", {
+      cause: error instanceof Error ? error.message : String(error)
+    });
+  }
+  const payloadResult = robotRockWebhookPayloadBodySchema.safeParse(parsedBody);
+  if (!payloadResult.success) {
+    throw new RobotRockWebhookError(
+      "Webhook payload schema validation failed",
+      "INVALID_PAYLOAD",
+      payloadResult.error.flatten()
+    );
+  }
+  return {
+    ...payloadResult.data,
+    headers: normalizeHeaders(request.headers)
+  };
 }
-async function askHuman(params) {
-  const {
-    task,
-    client: explicitClient,
-    apiKey,
-    baseUrl,
-    pollInterval = DEFAULT_POLL_INTERVAL_MS,
-    timeout = DEFAULT_TIMEOUT_MS,
-    idempotencyKey
-  } = params;
-  const client = resolveRobotRockClient(explicitClient, { apiKey, baseUrl });
-  const response = await client.createTask(
-    task,
-    { idempotencyKey }
-  );
-  const streamId = response.task.streamId;
-  const deadline = Date.now() + timeout;
-  while (Date.now() < deadline) {
-    const existing = await client.getTask(streamId);
-    if (existing?.status === "handled" && existing.handled) {
-      return toDiscriminatedApprovalResult(task.actions, existing, streamId);
+async function resolveWebhookSigningSecret(rawBody, options) {
+  if (options.secret) {
+    return options.secret;
+  }
+  if (options.resolveSecret) {
+    const taskId = peekWebhookTaskId(rawBody);
+    if (taskId) {
+      const resolved = await options.resolveSecret(taskId);
+      if (resolved) {
+        return resolved;
+      }
     }
-    if (existing?.status === "expired") {
-      throw new AskHumanExpiredError("Task expired before a human completed it");
+  }
+  return process.env.ROBOTROCK_WEBHOOK_SECRET;
+}
+function peekWebhookTaskId(rawBody) {
+  try {
+    const parsed = JSON.parse(rawBody);
+    if (typeof parsed === "object" && parsed !== null && "taskId" in parsed && typeof parsed.taskId === "string") {
+      return parsed.taskId;
     }
-    await sleep(pollInterval);
+  } catch {
   }
-  throw new AskHumanTimeoutError(`No human response within ${timeout}ms`);
+  return void 0;
+}
+function assertValidSignature(rawBody, signature, secret) {
+  const expected = `sha256=${createHmac("sha256", secret).update(rawBody).digest("hex")}`;
+  const expectedBuffer = Buffer.from(expected);
+  const receivedBuffer = Buffer.from(signature);
+  if (expectedBuffer.length !== receivedBuffer.length || !timingSafeEqual(expectedBuffer, receivedBuffer)) {
+    throw new RobotRockWebhookError("Webhook signature verification failed", "INVALID_SIGNATURE");
+  }
+}
+function normalizeHeaders(headers) {
+  const result = {};
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
 }
 export {
-  AskHumanExpiredError,
-  AskHumanTimeoutError,
   RobotRock,
   RobotRockError,
-  askHuman,
+  RobotRockWebhookError,
+  TaskExpiredError,
+  TaskTimeoutError,
+  assignToSchema,
+  attachWebhookToActions,
   createClient,
+  createTaskBodySchema,
   resolveRobotRockClient,
   resolveRobotRockConfig,
   taskContextSchema,
-  toDiscriminatedApprovalResult
+  toDiscriminatedApprovalResult,
+  verifyRobotRockWebhook
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/ask-human.ts"],"sourcesContent":["import {\n  AskHumanExpiredError,\n  AskHumanTimeoutError,\n  toDiscriminatedApprovalResult,\n} from \"./approval-result.js\";\nimport type { RobotRock, RobotRockConfig, CreateTaskOptions } from \"./client.js\";\nimport { resolveRobotRockClient } from \"./env.js\";\nimport type {\n  DiscriminatedApprovalResult,\n  TaskAction,\n  TaskContextInput,\n} from \"@robotrock/core\";\n\nconst DEFAULT_POLL_INTERVAL_MS = 2_000;\nconst DEFAULT_TIMEOUT_MS = 24 * 60 * 60 * 1_000;\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n/** Task payload for {@link askHuman}; `actions` must stay a literal tuple for inference. */\nexport type AskHumanTask<A extends readonly TaskAction[]> = Omit<TaskContextInput, \"actions\"> & {\n  readonly actions: A;\n};\n\nexport type AskHumanParams<A extends readonly TaskAction[]> = {\n  task: AskHumanTask<A>;\n  /** Pre-configured client; when omitted, one is created from env / `apiKey` / `baseUrl`. */\n  client?: RobotRock;\n  apiKey?: string;\n  baseUrl?: string;\n  /** Poll interval while waiting for a human (ms). @default 2000 */\n  pollInterval?: number;\n  /** Max wait time (ms). @default 86400000 (24h) */\n  timeout?: number;\n} & Pick<CreateTaskOptions, \"idempotencyKey\">;\n\n/**\n * Create a human-in-the-loop task and block until someone completes it.\n *\n * Uses polling against the RobotRock API. For durable waits inside Trigger.dev,\n * use `robotrock/trigger` instead.\n *\n * The return type is inferred from `task.actions`: `actionId` narrows `data`.\n */\nexport async function askHuman<const A extends readonly TaskAction[]>(\n  params: AskHumanParams<A>\n): Promise<DiscriminatedApprovalResult<A>> {\n  const {\n    task,\n    client: explicitClient,\n    apiKey,\n    baseUrl,\n    pollInterval = DEFAULT_POLL_INTERVAL_MS,\n    timeout = DEFAULT_TIMEOUT_MS,\n    idempotencyKey,\n  } = params;\n\n  const client = resolveRobotRockClient(explicitClient, { apiKey, baseUrl });\n  const response = await client.createTask(\n    task as unknown as TaskContextInput,\n    { idempotencyKey }\n  );\n  const streamId = response.task.streamId;\n  const deadline = Date.now() + timeout;\n\n  while (Date.now() < deadline) {\n    const existing = await client.getTask(streamId);\n\n    if (existing?.status === \"handled\" && existing.handled) {\n      return toDiscriminatedApprovalResult(task.actions, existing, streamId);\n    }\n\n    if (existing?.status === \"expired\") {\n      throw new AskHumanExpiredError(\"Task expired before a human completed it\");\n    }\n\n    await sleep(pollInterval);\n  }\n\n  throw new AskHumanTimeoutError(`No human response within ${timeout}ms`);\n}\n\nexport type { RobotRockConfig };\n"],"mappings":";;;;;;;;;;;;;AAaA,IAAM,2BAA2B;AACjC,IAAM,qBAAqB,KAAK,KAAK,KAAK;AAE1C,SAAS,MAAM,IAA2B;AACxC,SAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,EAAE,CAAC;AACzD;AA2BA,eAAsB,SACpB,QACyC;AACzC,QAAM;AAAA,IACJ;AAAA,IACA,QAAQ;AAAA,IACR;AAAA,IACA;AAAA,IACA,eAAe;AAAA,IACf,UAAU;AAAA,IACV;AAAA,EACF,IAAI;AAEJ,QAAM,SAAS,uBAAuB,gBAAgB,EAAE,QAAQ,QAAQ,CAAC;AACzE,QAAM,WAAW,MAAM,OAAO;AAAA,IAC5B;AAAA,IACA,EAAE,eAAe;AAAA,EACnB;AACA,QAAM,WAAW,SAAS,KAAK;AAC/B,QAAM,WAAW,KAAK,IAAI,IAAI;AAE9B,SAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,UAAM,WAAW,MAAM,OAAO,QAAQ,QAAQ;AAE9C,QAAI,UAAU,WAAW,aAAa,SAAS,SAAS;AACtD,aAAO,8BAA8B,KAAK,SAAS,UAAU,QAAQ;AAAA,IACvE;AAEA,QAAI,UAAU,WAAW,WAAW;AAClC,YAAM,IAAI,qBAAqB,0CAA0C;AAAA,IAC3E;AAEA,UAAM,MAAM,YAAY;AAAA,EAC1B;AAEA,QAAM,IAAI,qBAAqB,4BAA4B,OAAO,IAAI;AACxE;","names":[]}
+{"version":3,"sources":["../src/webhook.ts"],"sourcesContent":["import { createHmac, timingSafeEqual } from \"node:crypto\";\nimport { z } from \"zod\";\n\nconst ROBOTROCK_SIGNATURE_HEADER = \"x-robotrock-signature\";\n\nconst robotRockWebhookPayloadBodySchema = z.object({\n  taskId: z.string().min(1),\n  action: z.object({\n    id: z.string().min(1),\n    title: z.string().min(1),\n    data: z.unknown(),\n  }),\n  handledBy: z.string().min(1).optional(),\n  handledAt: z.string().min(1),\n  handlerType: z.string().min(1),\n});\n\nconst robotRockWebhookPayloadSchema = robotRockWebhookPayloadBodySchema.extend({\n  headers: z.record(z.string()),\n});\n\nexport type RobotRockWebhookErrorCode =\n  | \"MISSING_WEBHOOK_SECRET\"\n  | \"MISSING_SIGNATURE\"\n  | \"INVALID_SIGNATURE\"\n  | \"INVALID_JSON\"\n  | \"INVALID_PAYLOAD\";\n\nexport class RobotRockWebhookError extends Error {\n  constructor(\n    message: string,\n    public readonly code: RobotRockWebhookErrorCode,\n    public readonly details?: unknown\n  ) {\n    super(message);\n    this.name = \"RobotRockWebhookError\";\n  }\n}\n\nexport type RobotRockWebhookPayload = z.infer<typeof robotRockWebhookPayloadSchema>;\n\nexport interface VerifyRobotRockWebhookOptions {\n  /**\n   * Override shared secret (defaults to ROBOTROCK_WEBHOOK_SECRET).\n   * Keep undefined in production to enforce the canonical env var.\n   */\n  secret?: string;\n  /**\n   * Resolve the tenant signing secret by public task id (hosted MCP uses Convex).\n   * Used when secret is not passed explicitly.\n   */\n  resolveSecret?: (taskId: string) => Promise<string | undefined>;\n  /** Signature header to read. @default \"x-robotrock-signature\" */\n  signatureHeader?: string;\n}\n\n/**\n * Verify a RobotRock webhook request and return a validated payload.\n * Throws RobotRockWebhookError with machine-readable `code` for audit logging.\n */\nexport async function verifyRobotRockWebhook(\n  request: Request,\n  options: VerifyRobotRockWebhookOptions = {}\n): Promise<RobotRockWebhookPayload> {\n  const signatureHeaderName = options.signatureHeader ?? ROBOTROCK_SIGNATURE_HEADER;\n  const signature = request.headers.get(signatureHeaderName);\n\n  if (!signature) {\n    throw new RobotRockWebhookError(\n      `Missing webhook signature header: ${signatureHeaderName}`,\n      \"MISSING_SIGNATURE\"\n    );\n  }\n\n  const rawBody = await request.text();\n  const secret = await resolveWebhookSigningSecret(rawBody, options);\n\n  if (!secret) {\n    throw new RobotRockWebhookError(\n      \"Missing webhook signing secret for verification\",\n      \"MISSING_WEBHOOK_SECRET\"\n    );\n  }\n\n  assertValidSignature(rawBody, signature, secret);\n\n  let parsedBody: unknown;\n  try {\n    parsedBody = JSON.parse(rawBody);\n  } catch (error) {\n    throw new RobotRockWebhookError(\"Webhook body is not valid JSON\", \"INVALID_JSON\", {\n      cause: error instanceof Error ? error.message : String(error),\n    });\n  }\n\n  const payloadResult = robotRockWebhookPayloadBodySchema.safeParse(parsedBody);\n  if (!payloadResult.success) {\n    throw new RobotRockWebhookError(\n      \"Webhook payload schema validation failed\",\n      \"INVALID_PAYLOAD\",\n      payloadResult.error.flatten()\n    );\n  }\n\n  return {\n    ...payloadResult.data,\n    headers: normalizeHeaders(request.headers),\n  };\n}\n\nasync function resolveWebhookSigningSecret(\n  rawBody: string,\n  options: VerifyRobotRockWebhookOptions\n): Promise<string | undefined> {\n  if (options.secret) {\n    return options.secret;\n  }\n\n  if (options.resolveSecret) {\n    const taskId = peekWebhookTaskId(rawBody);\n    if (taskId) {\n      const resolved = await options.resolveSecret(taskId);\n      if (resolved) {\n        return resolved;\n      }\n    }\n  }\n\n  return process.env.ROBOTROCK_WEBHOOK_SECRET;\n}\n\nfunction peekWebhookTaskId(rawBody: string): string | undefined {\n  try {\n    const parsed: unknown = JSON.parse(rawBody);\n    if (\n      typeof parsed === \"object\" &&\n      parsed !== null &&\n      \"taskId\" in parsed &&\n      typeof (parsed as { taskId: unknown }).taskId === \"string\"\n    ) {\n      return (parsed as { taskId: string }).taskId;\n    }\n  } catch {\n    // fall through\n  }\n  return undefined;\n}\n\nfunction assertValidSignature(rawBody: string, signature: string, secret: string): void {\n  const expected = `sha256=${createHmac(\"sha256\", secret).update(rawBody).digest(\"hex\")}`;\n  const expectedBuffer = Buffer.from(expected);\n  const receivedBuffer = Buffer.from(signature);\n\n  if (\n    expectedBuffer.length !== receivedBuffer.length ||\n    !timingSafeEqual(expectedBuffer, receivedBuffer)\n  ) {\n    throw new RobotRockWebhookError(\"Webhook signature verification failed\", \"INVALID_SIGNATURE\");\n  }\n}\n\nfunction normalizeHeaders(headers: Headers): Record<string, string> {\n  const result: Record<string, string> = {};\n  headers.forEach((value, key) => {\n    result[key] = value;\n  });\n  return result;\n}\n"],"mappings":"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","names":[]}