pi-codex-search 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,123 @@
+# pi-codex-search
+
+[![npm](https://img.shields.io/npm/v/pi-codex-search)](https://www.npmjs.com/package/pi-codex-search)
+[![license](https://img.shields.io/npm/l/pi-codex-search)](./LICENSE)
+
+Pi extension that adds a `web_search` tool backed by the ChatGPT Codex backend.
+
+It reuses the `openai-codex` subscription already configured in pi-coding-agent. The extension does not read `ACCESS_TOKEN` during normal pi usage and does not start a separate login flow.
+
+## Install
+
+Local checkout:
+
+```bash
+pi -e /path/to/pi-codex-search
+```
+
+After publishing, the package can be installed through pi's npm package path:
+
+```bash
+pi install npm:pi-codex-search
+```
+
+The package manifest exposes the extension through:
+
+```json
+{
+  "pi": {
+    "extensions": ["./index.ts"]
+  }
+}
+```
+
+## Authentication
+
+Inside `pi`, run:
+
+```text
+/login openai-codex
+```
+
+Choose `ChatGPT Plus/Pro (Codex Subscription)` if pi prompts for a provider. Credentials are stored in pi's auth file and refreshed by pi.
+
+At `session_start`, this extension calls `ctx.modelRegistry.getApiKeyForProvider("openai-codex")`. If no token is available, or if the account id cannot be found from the stored OAuth credential or decoded access token, it does not register `web_search`. In that case the model will not see the tool.
+
+## Usage
+
+When Codex auth is available at session start, the extension registers:
+
+```json
+{
+  "name": "web_search",
+  "arguments": {
+    "query": "latest OpenAI Codex release notes",
+    "search_context_size": "medium",
+    "live": true
+  }
+}
+```
+
+Parameters:
+
+- `query`: required search question.
+- `search_context_size`: optional, one of `low`, `medium`, `high`.
+- `live`: optional boolean. Defaults to live web access.
+
+Model selection:
+
+- If `PI_CODEX_WEB_SEARCH_MODEL` is set, that model id is used.
+- Otherwise, if the active pi model provider is `openai-codex`, the active model id is used.
+- Otherwise, the extension fetches `/codex/models?client_version=...` and uses the default model from that response.
+
+The tool returns text content. Its structured `details` include:
+
+- `model`
+- `responseId`
+- `searchCalls`
+- `citations`
+- `usage`
+
+## Configuration
+
+- `PI_CODEX_WEB_SEARCH_MODEL`: override the Codex model used by the tool.
+- `PI_CODEX_WEB_SEARCH_BASE_URL`: override the Codex backend base URL.
+- `PI_CODEX_WEB_SEARCH_CLIENT_VERSION`: override the `client_version` sent to `/codex/models`.
+- `PI_CODEX_WEB_SEARCH_CONTEXT_SIZE`: default search context size: `low`, `medium`, or `high`.
+- `PI_CODEX_WEB_SEARCH_LIVE`: set to `false` to use cached web access.
+
+The request headers are built by the extension. They include `Authorization`, `chatgpt-account-id`, `originator: pi`, `OpenAI-Beta: responses=experimental`, `accept`, and `content-type` for streaming response requests.
+
+## Development
+
+```bash
+npm install
+npm run check
+npm test
+npm run lint
+npm run format:check
+```
+
+## Release
+
+This repository follows the same release shape as `pi-provider-kimi-code`:
+
+- `release-naming.env` defines `PKG_NAME=pi-codex-search` and `TAG_PREFIX=v`.
+- `scripts/next-version.sh` computes the next semantic version from tags.
+- `.github/workflows/release-command.yml` creates release commits and tags.
+- `.github/workflows/release-on-tag.yml` publishes to npm with provenance and attaches `pi-codex-search.tar.gz` to the GitHub release.
+
+GitHub release tarball installs from the extracted directory:
+
+```bash
+curl -L https://github.com/Leechael/pi-codex-search/releases/latest/download/pi-codex-search.tar.gz | tar -xz -C /tmp
+pi install /tmp/pi-codex-search
+```
+
+## References
+
+- Upstream harness: [earendil-works/pi](https://github.com/earendil-works/pi) · [pi-coding-agent](https://github.com/earendil-works/pi/tree/main/packages/coding-agent)
+
+## License
+
+MIT

package/index.ts

@@ -0,0 +1,163 @@
+import { StringEnum, Type } from "@earendil-works/pi-ai";
+import {
+  defineTool,
+  type ExtensionAPI,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+  extractAccountIdFromToken,
+  fetchCodexModels,
+  fetchCodexWebSearch,
+  selectDefaultModel,
+  type SearchContextSize,
+} from "./src/codex.ts";
+
+const OPENAI_CODEX_PROVIDER = "openai-codex";
+const DEFAULT_CONTEXT_SIZE = "medium";
+
+const webSearchTool = defineTool({
+  name: "web_search",
+  label: "Web Search",
+  description:
+    "Search the web using the user's configured ChatGPT Codex subscription and return an answer with sources.",
+  promptSnippet: "web_search: search the web using the configured ChatGPT Codex subscription.",
+  promptGuidelines: [
+    "Use web_search when current or source-backed information is needed.",
+    "Do not ask the user for an access token; the tool uses pi's configured OpenAI Codex subscription.",
+  ],
+  parameters: Type.Object({
+    query: Type.String({ description: "The web search question to answer." }),
+    search_context_size: Type.Optional(
+      StringEnum(["low", "medium", "high"] as const, {
+        description: "Amount of web context to retrieve. Defaults to medium.",
+      }),
+    ),
+    live: Type.Optional(Type.Boolean({ description: "Use live web access. Defaults to true." })),
+  }),
+
+  async execute(_toolCallId, params, signal, onUpdate, ctx) {
+    const query = params.query.trim();
+    if (!query) {
+      throw new Error("query must not be empty");
+    }
+
+    const token = await ctx.modelRegistry.getApiKeyForProvider(OPENAI_CODEX_PROVIDER);
+    if (!token) {
+      throw new Error(
+        "OpenAI Codex subscription is not configured. Run /login and choose ChatGPT Plus/Pro.",
+      );
+    }
+
+    const accountId = getConfiguredAccountId(ctx, token);
+    if (!accountId) {
+      throw new Error(
+        "OpenAI Codex account id was not found in stored credentials or access token.",
+      );
+    }
+
+    const baseUrl = process.env.PI_CODEX_WEB_SEARCH_BASE_URL;
+    const model = await resolveSearchModel(ctx, token, accountId, baseUrl, signal);
+    let streamedText = "";
+
+    const result = await fetchCodexWebSearch({
+      query,
+      token,
+      accountId,
+      model,
+      baseUrl,
+      externalWebAccess: resolveLive(params.live),
+      searchContextSize: resolveSearchContextSize(params.search_context_size),
+      signal,
+      onTextDelta: (delta) => {
+        streamedText += delta;
+        onUpdate?.({
+          content: [{ type: "text", text: streamedText }],
+          details: { model, partial: true },
+        });
+      },
+    });
+
+    return {
+      content: [{ type: "text", text: formatToolText(result.text, result.citations) }],
+      details: {
+        model: result.model,
+        responseId: result.responseId,
+        searchCalls: result.searchCalls,
+        citations: result.citations,
+        usage: result.usage,
+      },
+    };
+  },
+});
+
+export default function codexWebSearchExtension(pi: ExtensionAPI) {
+  let registered = false;
+
+  pi.on("session_start", async (_event, ctx) => {
+    if (registered) return;
+
+    const token = await ctx.modelRegistry.getApiKeyForProvider(OPENAI_CODEX_PROVIDER);
+    if (!token || !getConfiguredAccountId(ctx, token)) {
+      return;
+    }
+
+    pi.registerTool(webSearchTool);
+    registered = true;
+  });
+}
+
+function getConfiguredAccountId(ctx: ExtensionContext, token: string): string | undefined {
+  const credential = ctx.modelRegistry.authStorage.get(OPENAI_CODEX_PROVIDER);
+  if (credential?.type === "oauth" && typeof credential.accountId === "string") {
+    return credential.accountId;
+  }
+  return extractAccountIdFromToken(token);
+}
+
+async function resolveSearchModel(
+  ctx: ExtensionContext,
+  token: string,
+  accountId: string,
+  baseUrl: string | undefined,
+  signal: AbortSignal | undefined,
+): Promise<string> {
+  const override = process.env.PI_CODEX_WEB_SEARCH_MODEL?.trim();
+  if (override) return override;
+  if (ctx.model?.provider === OPENAI_CODEX_PROVIDER) return ctx.model.id;
+
+  const models = await fetchCodexModels({
+    token,
+    accountId,
+    baseUrl,
+    clientVersion: process.env.PI_CODEX_WEB_SEARCH_CLIENT_VERSION,
+    signal,
+  });
+  const model = selectDefaultModel(models);
+  if (!model) {
+    throw new Error("Codex model list is empty.");
+  }
+  return model;
+}
+
+function resolveSearchContextSize(value: string | undefined): SearchContextSize {
+  const configured = value ?? process.env.PI_CODEX_WEB_SEARCH_CONTEXT_SIZE ?? DEFAULT_CONTEXT_SIZE;
+  if (configured === "low" || configured === "medium" || configured === "high") {
+    return configured;
+  }
+  throw new Error(`Invalid search_context_size: ${configured}`);
+}
+
+function resolveLive(value: boolean | undefined): boolean {
+  if (value !== undefined) return value;
+  return process.env.PI_CODEX_WEB_SEARCH_LIVE !== "false";
+}
+
+function formatToolText(text: string, citations: Array<{ title?: string; url: string }>): string {
+  if (citations.length === 0) return text || "(no response text)";
+
+  const sourceLines = citations.map((citation, index) => {
+    const title = citation.title?.trim() || citation.url;
+    return `${index + 1}. ${title}: ${citation.url}`;
+  });
+  return `${text || "(no response text)"}\n\nSources:\n${sourceLines.join("\n")}`;
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "pi-codex-search",
+  "version": "0.1.0",
+  "description": "Pi extension for Codex Web Search — reuse your ChatGPT Plus/Pro Codex subscription in pi-coding-agent",
+  "keywords": [
+    "chatgpt",
+    "chatgpt-plus",
+    "chatgpt-pro",
+    "codex",
+    "coding-agent",
+    "oauth",
+    "openai",
+    "openai-codex",
+    "pi",
+    "pi-coding-agent",
+    "pi-extension",
+    "pi-mono",
+    "pi-package",
+    "responses-api",
+    "subscription",
+    "tool-extension",
+    "web-search",
+    "web_search"
+  ],
+  "bugs": {
+    "url": "https://github.com/Leechael/pi-codex-search/issues"
+  },
+  "license": "MIT",
+  "author": "Leechael",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Leechael/pi-codex-search"
+  },
+  "files": [
+    "index.ts",
+    "src",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "scripts": {
+    "clean": "echo 'nothing to clean'",
+    "build": "echo 'nothing to build'",
+    "check": "tsc --noEmit",
+    "test": "node --test tests/*.test.ts",
+    "lint": "oxlint .",
+    "format": "oxfmt . --write",
+    "format:check": "oxfmt . --check",
+    "pre-commit": "prek run"
+  },
+  "devDependencies": {
+    "@j178/prek": "^0.3.8",
+    "@types/node": "^24.0.0",
+    "oxfmt": "^0.44.0",
+    "oxlint": "^1.59.0",
+    "typescript": "^5.9.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

package/src/codex.ts

@@ -0,0 +1,396 @@
+export type SearchContextSize = "low" | "medium" | "high";
+
+export interface CodexModel {
+  id: string;
+  name?: string;
+  isDefault?: boolean;
+}
+
+export interface CodexWebSearchOptions {
+  query: string;
+  token: string;
+  accountId: string;
+  model: string;
+  baseUrl?: string;
+  externalWebAccess?: boolean;
+  searchContextSize?: SearchContextSize;
+  signal?: AbortSignal;
+  onTextDelta?: (delta: string) => void;
+  fetchImpl?: typeof fetch;
+}
+
+export interface CodexCitation {
+  title?: string;
+  url: string;
+  startIndex?: number;
+  endIndex?: number;
+}
+
+export interface CodexSearchCall {
+  id?: string;
+  status?: string;
+  query?: string;
+  url?: string;
+  actionType?: string;
+}
+
+export interface CodexWebSearchResult {
+  responseId?: string;
+  model: string;
+  text: string;
+  searchCalls: CodexSearchCall[];
+  citations: CodexCitation[];
+  usage?: {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+  };
+}
+
+interface SseEvent {
+  type: string;
+  data?: unknown;
+  raw?: string;
+}
+
+interface ResponseOutputText {
+  type?: string;
+  text?: string;
+  annotations?: Array<{
+    type?: string;
+    title?: string;
+    url?: string;
+    start_index?: number;
+    end_index?: number;
+  }>;
+}
+
+interface ResponseOutputItem {
+  id?: string;
+  type?: string;
+  status?: string;
+  role?: string;
+  action?: {
+    type?: string;
+    query?: string;
+    queries?: string[];
+    url?: string;
+  };
+  content?: ResponseOutputText[];
+}
+
+interface ResponseUsage {
+  input_tokens?: number;
+  output_tokens?: number;
+  total_tokens?: number;
+}
+
+interface ResponseEnvelope {
+  id?: string;
+  usage?: ResponseUsage;
+}
+
+interface ResponseEventData {
+  response?: ResponseEnvelope;
+  item?: ResponseOutputItem;
+  delta?: string;
+  error?: {
+    message?: string;
+    code?: string;
+  };
+}
+
+const DEFAULT_BASE_URL = "https://chatgpt.com/backend-api";
+const DEFAULT_CLIENT_VERSION = "1.0.0";
+const ACCOUNT_ID_CLAIM = "https://api.openai.com/auth";
+
+export function normalizeCodexBaseUrl(baseUrl: string | undefined): string {
+  const raw = baseUrl && baseUrl.trim().length > 0 ? baseUrl : DEFAULT_BASE_URL;
+  const normalized = raw.replace(/\/+$/, "");
+  if (normalized.endsWith("/codex/responses"))
+    return normalized.slice(0, -"/codex/responses".length);
+  if (normalized.endsWith("/codex")) return normalized.slice(0, -"/codex".length);
+  return normalized;
+}
+
+export function resolveCodexEndpoint(
+  baseUrl: string | undefined,
+  path: "models" | "responses",
+): string {
+  return `${normalizeCodexBaseUrl(baseUrl)}/codex/${path}`;
+}
+
+export function extractAccountIdFromToken(token: string): string | undefined {
+  const parts = token.split(".");
+  if (parts.length !== 3) return undefined;
+
+  try {
+    const payload = JSON.parse(Buffer.from(parts[1] ?? "", "base64url").toString("utf8")) as {
+      [ACCOUNT_ID_CLAIM]?: { chatgpt_account_id?: unknown };
+    };
+    const accountId = payload[ACCOUNT_ID_CLAIM]?.chatgpt_account_id;
+    return typeof accountId === "string" && accountId.length > 0 ? accountId : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function fetchCodexModels(options: {
+  token: string;
+  accountId: string;
+  baseUrl?: string;
+  clientVersion?: string;
+  fetchImpl?: typeof fetch;
+  signal?: AbortSignal;
+}): Promise<CodexModel[]> {
+  const fetcher = options.fetchImpl ?? fetch;
+  const endpoint = new URL(resolveCodexEndpoint(options.baseUrl, "models"));
+  endpoint.searchParams.set(
+    "client_version",
+    options.clientVersion ??
+      process.env.PI_CODEX_WEB_SEARCH_CLIENT_VERSION ??
+      DEFAULT_CLIENT_VERSION,
+  );
+
+  const response = await fetcher(endpoint.toString(), {
+    headers: buildCodexHeaders(options.token, options.accountId, "application/json"),
+    signal: options.signal,
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Codex models request failed: HTTP ${response.status} ${await response.text()}`,
+    );
+  }
+
+  const data = (await response.json()) as {
+    models?: Array<{
+      slug?: string;
+      id?: string;
+      model?: string;
+      display_name?: string;
+      is_default?: boolean;
+    }>;
+  };
+  return (data.models ?? [])
+    .map((model) => ({
+      id: model.slug ?? model.id ?? model.model ?? "",
+      name: model.display_name,
+      isDefault: model.is_default,
+    }))
+    .filter((model) => model.id.length > 0);
+}
+
+export function selectDefaultModel(models: CodexModel[]): string | undefined {
+  return (models.find((model) => model.isDefault) ?? models[0])?.id;
+}
+
+export async function fetchCodexWebSearch(
+  options: CodexWebSearchOptions,
+): Promise<CodexWebSearchResult> {
+  const fetcher = options.fetchImpl ?? fetch;
+  const response = await fetcher(resolveCodexEndpoint(options.baseUrl, "responses"), {
+    method: "POST",
+    headers: buildCodexHeaders(options.token, options.accountId, "text/event-stream"),
+    body: JSON.stringify(buildWebSearchRequestBody(options)),
+    signal: options.signal,
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `Codex web search request failed: HTTP ${response.status} ${await response.text()}`,
+    );
+  }
+  if (!response.body) {
+    throw new Error("Codex web search response did not include a body");
+  }
+
+  let responseId: string | undefined;
+  let usage: ResponseUsage | undefined;
+  let streamedText = "";
+  const messageTextParts: string[] = [];
+  const searchCalls = new Map<string, CodexSearchCall>();
+  const citations = new Map<string, CodexCitation>();
+
+  for await (const event of parseSse(response.body)) {
+    const data = event.data as ResponseEventData | undefined;
+    if (!data) continue;
+
+    if (event.type === "response.created") {
+      responseId = data.response?.id;
+      continue;
+    }
+
+    if (event.type === "response.output_text.delta") {
+      const delta = data.delta ?? "";
+      streamedText += delta;
+      options.onTextDelta?.(delta);
+      continue;
+    }
+
+    if (event.type === "response.output_item.added" && data.item?.type === "web_search_call") {
+      const item = data.item;
+      searchCalls.set(item.id ?? `search-${searchCalls.size + 1}`, {
+        id: item.id,
+        status: item.status,
+      });
+      continue;
+    }
+
+    if (event.type === "response.output_item.done") {
+      collectOutputItem(data.item, searchCalls, messageTextParts, citations);
+      continue;
+    }
+
+    if (event.type === "response.completed") {
+      usage = data.response?.usage;
+      continue;
+    }
+
+    if (event.type === "response.failed") {
+      throw new Error(data.error?.message ?? data.error?.code ?? "Codex web search failed");
+    }
+  }
+
+  return {
+    responseId,
+    model: options.model,
+    text: messageTextParts.join("") || streamedText,
+    searchCalls: [...searchCalls.values()],
+    citations: [...citations.values()],
+    usage: usage
+      ? {
+          inputTokens: usage.input_tokens,
+          outputTokens: usage.output_tokens,
+          totalTokens: usage.total_tokens,
+        }
+      : undefined,
+  };
+}
+
+function buildCodexHeaders(token: string, accountId: string, accept: string): Headers {
+  const headers = new Headers();
+  headers.set("Authorization", `Bearer ${token}`);
+  headers.set("chatgpt-account-id", accountId);
+  headers.set("originator", "pi");
+  headers.set("OpenAI-Beta", "responses=experimental");
+  headers.set("accept", accept);
+  if (accept === "text/event-stream") {
+    headers.set("content-type", "application/json");
+  }
+  headers.set("User-Agent", "pi-codex-search");
+  return headers;
+}
+
+function buildWebSearchRequestBody(options: CodexWebSearchOptions) {
+  return {
+    model: options.model,
+    instructions:
+      "You are a concise web search assistant. Use web search, answer the query, and preserve source citations from annotations.",
+    input: [
+      {
+        type: "message",
+        role: "user",
+        content: [{ type: "input_text", text: options.query }],
+      },
+    ],
+    tools: [
+      {
+        type: "web_search",
+        external_web_access: options.externalWebAccess ?? true,
+        search_context_size: options.searchContextSize ?? "medium",
+      },
+    ],
+    tool_choice: "required",
+    parallel_tool_calls: true,
+    store: false,
+    stream: true,
+    include: [],
+  };
+}
+
+async function* parseSse(body: ReadableStream<Uint8Array>): AsyncGenerator<SseEvent> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+
+    let separatorIndex = buffer.indexOf("\n\n");
+    while (separatorIndex !== -1) {
+      const frame = buffer.slice(0, separatorIndex);
+      buffer = buffer.slice(separatorIndex + 2);
+      const event = parseSseFrame(frame);
+      if (event) yield event;
+      separatorIndex = buffer.indexOf("\n\n");
+    }
+  }
+
+  buffer += decoder.decode();
+  const event = parseSseFrame(buffer);
+  if (event) yield event;
+}
+
+function parseSseFrame(frame: string): SseEvent | undefined {
+  const lines = frame.split(/\r?\n/);
+  let type = "";
+  const dataLines: string[] = [];
+
+  for (const line of lines) {
+    if (line.startsWith("event:")) {
+      type = line.slice("event:".length).trim();
+    } else if (line.startsWith("data:")) {
+      dataLines.push(line.slice("data:".length).trimStart());
+    }
+  }
+
+  if (dataLines.length === 0) return undefined;
+  const raw = dataLines.join("\n");
+  if (raw === "[DONE]") return undefined;
+
+  try {
+    return { type, data: JSON.parse(raw) };
+  } catch {
+    return { type, raw };
+  }
+}
+
+function collectOutputItem(
+  item: ResponseOutputItem | undefined,
+  searchCalls: Map<string, CodexSearchCall>,
+  messageTextParts: string[],
+  citations: Map<string, CodexCitation>,
+): void {
+  if (!item) return;
+
+  if (item.type === "web_search_call") {
+    const key = item.id ?? `search-${searchCalls.size + 1}`;
+    const query = item.action?.query ?? item.action?.queries?.join(", ");
+    searchCalls.set(key, {
+      id: item.id,
+      status: item.status,
+      query,
+      url: item.action?.url,
+      actionType: item.action?.type,
+    });
+    return;
+  }
+
+  if (item.type !== "message" || item.role !== "assistant") return;
+
+  for (const part of item.content ?? []) {
+    if (part.type !== "output_text") continue;
+    messageTextParts.push(part.text ?? "");
+    for (const annotation of part.annotations ?? []) {
+      if (annotation.type !== "url_citation" || !annotation.url) continue;
+      citations.set(annotation.url, {
+        title: annotation.title,
+        url: annotation.url,
+        startIndex: annotation.start_index,
+        endIndex: annotation.end_index,
+      });
+    }
+  }
+}