@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-eyk9wdct.js

@@ -0,0 +1,61 @@
+import {
+  InvalidError
+} from "./location-mutation-nr76rjj3.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/config/variable.ts
+var exports_variable = {};
+__export(exports_variable, {
+  substitute: () => substitute,
+  ConfigVariable: () => exports_variable
+});
+import os from "os";
+import path from "path";
+import { Effect } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+var substitute = Effect.fn("ConfigVariable.substitute")(function* (input) {
+  const text = input.text.replace(/\{env:([^}]+)\}/g, (_, varName) => (input.env?.[varName] ?? process.env[varName]) || "");
+  if (!text.includes("{file:"))
+    return text;
+  return yield* substituteFiles(input, text);
+});
+var substituteFiles = Effect.fnUntraced(function* (input, text) {
+  const fs = yield* FSUtil.Service;
+  const configDir = input.type === "path" ? path.dirname(input.path) : input.dir;
+  const configSource = input.type === "path" ? input.path : input.source;
+  const matches = Array.from(text.matchAll(/\{file:[^}]+\}/g));
+  let out = "";
+  let cursor = 0;
+  for (const match of matches) {
+    const token = match[0];
+    const index = match.index;
+    out += text.slice(cursor, index);
+    const lineStart = text.lastIndexOf(`
+`, index - 1) + 1;
+    const prefix = text.slice(lineStart, index).trimStart();
+    if (prefix.startsWith("//")) {
+      out += token;
+      cursor = index + token.length;
+      continue;
+    }
+    const filePath = token.replace(/^\{file:/, "").replace(/\}$/, "");
+    const expandedPath = filePath.startsWith("~/") ? path.join(os.homedir(), filePath.slice(2)) : filePath;
+    const resolvedPath = path.isAbsolute(expandedPath) ? expandedPath : path.resolve(configDir, expandedPath);
+    const fileContent = yield* fs.readFileString(resolvedPath).pipe(Effect.catch((error) => {
+      if (input.missing === "empty")
+        return Effect.succeed("");
+      const message = `bad file reference: "${token}"`;
+      return Effect.fail(new InvalidError({
+        path: configSource,
+        message: error._tag === "PlatformError" && error.reason._tag === "NotFound" ? `${message} ${resolvedPath} does not exist` : message
+      }, { cause: error }));
+    }));
+    out += JSON.stringify(fileContent.trim()).slice(1, -1);
+    cursor = index + token.length;
+  }
+  return out + text.slice(cursor);
+});
+
+export { substitute, exports_variable };

package/dist/chunks/location-mutation-ezs3tagn.js

@@ -0,0 +1,54 @@
+// src/github-copilot/chat/openai-compatible-prepare-tools.ts
+import { UnsupportedFunctionalityError } from "@ai-sdk/provider";
+function prepareTools({
+  tools,
+  toolChoice
+}) {
+  tools = tools?.length ? tools : undefined;
+  const toolWarnings = [];
+  if (tools == null) {
+    return { tools: undefined, toolChoice: undefined, toolWarnings };
+  }
+  const openaiCompatTools = [];
+  for (const tool of tools) {
+    if (tool.type === "provider") {
+      toolWarnings.push({ type: "unsupported", feature: `tool type: ${tool.type}` });
+    } else {
+      openaiCompatTools.push({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema
+        }
+      });
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: openaiCompatTools, toolChoice: undefined, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: openaiCompatTools, toolChoice: type, toolWarnings };
+    case "tool":
+      return {
+        tools: openaiCompatTools,
+        toolChoice: {
+          type: "function",
+          function: { name: toolChoice.toolName }
+        },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+
+export { prepareTools };

package/dist/chunks/location-mutation-f05p34aa.js

@@ -0,0 +1,80 @@
+import {
+  exports_mcp
+} from "./location-mutation-1c00jchy.js";
+import {
+  exports_app
+} from "./location-mutation-50jxp3hw.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/websearch/firecrawl.ts
+var exports_firecrawl = {};
+__export(exports_firecrawl, {
+  endpoint: () => endpoint,
+  WebSearchFirecrawl: () => exports_firecrawl,
+  Plugin: () => Plugin
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Option, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+var endpoint = "https://mcp.firecrawl.dev/v2/mcp";
+var McpInput = Schema.Struct({
+  query: Schema.String,
+  limit: Schema.Number.pipe(Schema.optional)
+});
+var McpOutput = Schema.Struct({
+  content: Schema.Array(Schema.Struct({ type: Schema.Literal("text"), text: Schema.String }))
+});
+var SearchResponse = Schema.fromJsonString(Schema.Struct({
+  success: Schema.Boolean,
+  data: Schema.Struct({
+    web: Schema.Array(Schema.Struct({
+      url: Schema.String,
+      title: Schema.NullOr(Schema.String).pipe(Schema.optional),
+      description: Schema.NullOr(Schema.String).pipe(Schema.optional)
+    }))
+  })
+}));
+var decodeSearchResponse = Schema.decodeUnknownOption(SearchResponse);
+var Plugin = define({
+  id: "opencode.websearch.firecrawl",
+  effect: Effect.fn("WebSearchFirecrawl.Plugin")(function* (ctx) {
+    const http = yield* HttpClient.HttpClient;
+    yield* ctx.integration.transform((draft) => {
+      draft.update("firecrawl", (integration) => integration.name = "Firecrawl");
+      draft.method.update({
+        integrationID: "firecrawl",
+        method: { type: "key" }
+      });
+      draft.method.update({
+        integrationID: "firecrawl",
+        method: { type: "env", names: ["FIRECRAWL_API_KEY"] }
+      });
+    });
+    yield* ctx.websearch.transform((draft) => {
+      draft.add({
+        id: "firecrawl",
+        name: "Firecrawl",
+        execute: (input) => Effect.gen(function* () {
+          const connection = yield* ctx.integration.connection.active("firecrawl");
+          const credential = connection ? yield* ctx.integration.connection.resolve(connection) : undefined;
+          const result = yield* exports_mcp.call(http, endpoint, "firecrawl_search", { input: McpInput, output: McpOutput }, { query: input.query, limit: 8 }, {
+            "User-Agent": exports_app.useragent(ctx.app),
+            ...credential?.type === "key" ? { Authorization: `Bearer ${credential.key}` } : {}
+          });
+          const content = result?.content.find((item) => item.text);
+          const response = content ? Option.getOrUndefined(decodeSearchResponse(content.text)) : undefined;
+          return response?.data.web.map((item) => ({
+            url: item.url,
+            ...item.title ? { title: item.title } : {},
+            ...item.description ? { content: item.description } : {},
+            time: {}
+          })) ?? [];
+        })
+      });
+    });
+  })
+});
+
+export { endpoint, Plugin, exports_firecrawl };

package/dist/chunks/location-mutation-f4cp4g4a.js

@@ -0,0 +1,17 @@
+// src/database/migration/20260622170816_reset_v2_session_state.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260622170816_reset_v2_session_state",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DELETE FROM \`session_context_epoch\`;`);
+      yield* tx.run(`DELETE FROM \`session_input\`;`);
+      yield* tx.run(`DELETE FROM \`session_message\`;`);
+      yield* tx.run(`DELETE FROM \`event\`;`);
+      yield* tx.run(`DELETE FROM \`event_sequence\`;`);
+    });
+  }
+};
+var _20260622170816_reset_v2_session_state_default = migration;
+
+export { _20260622170816_reset_v2_session_state_default };

package/dist/chunks/location-mutation-f4n7jts7.js

@@ -0,0 +1,82 @@
+import {
+  exports_reference
+} from "./location-mutation-rzy4xjjz.js";
+import {
+  exports_instructions
+} from "./location-mutation-8k8ks5a6.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/reference/instructions.ts
+var exports_instructions2 = {};
+__export(exports_instructions2, {
+  node: () => node,
+  Service: () => Service,
+  ReferenceInstructions: () => exports_instructions2
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+var Summary = Schema.Struct({
+  name: Schema.String,
+  path: Schema.String,
+  description: Schema.String.pipe(Schema.optional)
+});
+var entries = (references) => references.flatMap((reference) => [
+  "  <reference>",
+  `    <name>${reference.name}</name>`,
+  `    <path>${reference.path}</path>`,
+  ...reference.description === undefined ? [] : [`    <description>${reference.description}</description>`],
+  "  </reference>"
+]);
+var render = (references) => [
+  "Project references provide additional directories that can be accessed when relevant.",
+  "<available_references>",
+  ...entries(references),
+  "</available_references>"
+].join(`
+`);
+var update = (previous, current) => {
+  const diff = exports_instructions.diffByKey(previous, current, (reference) => reference.name, (before, after) => before.path !== after.path || before.description !== after.description);
+  if (diff.changed.length > 0 || diff.added.length === 0 && diff.removed.length === 0)
+    return [
+      "The available project references have changed. This list supersedes the previous reference list.",
+      render(current)
+    ].join(`
+`);
+  return [
+    ...diff.added.length === 0 ? [] : ["New project references are available in addition to those previously listed:", ...entries(diff.added)],
+    ...diff.removed.length === 0 ? [] : [
+      `The following project references are no longer available and must not be used: ${diff.removed.map((reference) => reference.name).join(", ")}.`
+    ]
+  ].join(`
+`);
+};
+
+class Service extends Context.Service()("@opencode/ReferenceInstructions") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const references = yield* exports_reference.Service;
+  return Service.of({
+    load: Effect.fn("ReferenceInstructions.load")(function* () {
+      const available = (yield* references.list()).filter((reference) => reference.description !== undefined).map((reference) => ({
+        name: reference.name,
+        path: reference.path,
+        description: reference.description
+      })).toSorted((a, b) => a.name.localeCompare(b.name));
+      return exports_instructions.make({
+        key: exports_instructions.Key.make("core/reference-guidance"),
+        codec: Schema.toCodecJson(Schema.Array(Summary)),
+        read: Effect.succeed(available.length === 0 ? exports_instructions.removed : available),
+        render: {
+          initial: render,
+          changed: update,
+          removed: () => "Project reference guidance is no longer available. Do not use previously listed references."
+        }
+      });
+    })
+  });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_reference.node] });
+
+export { Service, node, exports_instructions2 as exports_instructions };

package/dist/chunks/location-mutation-f84sxdqn.js

@@ -0,0 +1,49 @@
+// src/database/drizzle/up-migrations/utils.ts
+var MIGRATIONS_TABLE_VERSIONS = {
+  sqlite: 1,
+  pg: 1,
+  effect: 1,
+  mysql: 1,
+  mssql: 1,
+  cockroach: 1,
+  singlestore: 1
+};
+var GET_VERSION_FOR = {
+  mysql: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  pg: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  effect: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  mssql: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  cockroach: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  singlestore: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  },
+  sqlite: (columns) => {
+    if (columns.includes("name"))
+      return 1;
+    return 0;
+  }
+};
+
+export { MIGRATIONS_TABLE_VERSIONS, GET_VERSION_FOR };

package/dist/chunks/location-mutation-fa4tegb4.js

@@ -0,0 +1,279 @@
+import {
+  exports_page
+} from "./location-mutation-7mrpdsq5.js";
+import {
+  exports_app
+} from "./location-mutation-50jxp3hw.js";
+import {
+  exports_integration
+} from "./location-mutation-67ww7a6n.js";
+import {
+  exports_credential
+} from "./location-mutation-xvc235nh.js";
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __require
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/provider/openai.ts
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Deferred, Effect, Option, Schema, Semaphore, Stream } from "effect";
+var clientID = "app_EMoamEEZ73f0CkXaXp7hrann";
+var issuer = "https://auth.openai.com";
+var callbackPort = 1455;
+var pollingSafetyMargin = 3000;
+var codexBaseURL = "https://chatgpt.com/backend-api/codex";
+var browserMethodID = exports_integration.MethodID.make("chatgpt-browser");
+var headlessMethodID = exports_integration.MethodID.make("chatgpt-headless");
+var codexAllowed = new Set(["gpt-5.5", "gpt-5.3-codex-spark", "gpt-5.4", "gpt-5.4-mini"]);
+var codexDisallowed = new Set(["gpt-5.5-pro", "gpt-5.6"]);
+var Claims = Schema.fromJsonString(Schema.Struct({
+  chatgpt_account_id: Schema.optional(Schema.String),
+  organizations: Schema.optional(Schema.Array(Schema.Struct({ id: Schema.String }))),
+  "https://api.openai.com/auth": Schema.optional(Schema.Struct({ chatgpt_account_id: Schema.optional(Schema.String) }))
+}));
+var decodeClaims = Schema.decodeUnknownOption(Claims);
+var browser = (app) => ({
+  integrationID: exports_integration.ID.make("openai"),
+  method: {
+    id: browserMethodID,
+    type: "oauth",
+    label: "ChatGPT Pro/Plus (browser)"
+  },
+  authorize: () => Effect.gen(function* () {
+    const pkce = yield* Effect.promise(generatePKCE);
+    const state = base64UrlEncode(crypto.getRandomValues(new Uint8Array(32)).buffer);
+    const code = yield* Deferred.make();
+    const redirect = `http://localhost:${callbackPort}/auth/callback`;
+    const { createServer } = yield* Effect.promise(() => import("node:http"));
+    const server = createServer((request, response) => {
+      const url = new URL(request.url ?? "/", `http://localhost:${callbackPort}`);
+      if (url.pathname !== "/auth/callback") {
+        response.writeHead(404).end("Not found");
+        return;
+      }
+      const error = url.searchParams.get("error_description") ?? url.searchParams.get("error");
+      const value = url.searchParams.get("code");
+      if (error) {
+        Effect.runFork(Deferred.fail(code, new Error(error)));
+        response.writeHead(400, { "Content-Type": "text/html" }).end(exports_page.error(error, { provider: "ChatGPT" }));
+        return;
+      }
+      if (!value || url.searchParams.get("state") !== state) {
+        const message = value ? "Invalid OAuth state" : "Missing authorization code";
+        Effect.runFork(Deferred.fail(code, new Error(message)));
+        response.writeHead(400, { "Content-Type": "text/html" }).end(exports_page.error(message, { provider: "ChatGPT" }));
+        return;
+      }
+      Effect.runFork(Deferred.succeed(code, value));
+      response.writeHead(200, { "Content-Type": "text/html" }).end(exports_page.success({ provider: "ChatGPT" }));
+    });
+    yield* Effect.callback((resume) => {
+      server.once("error", (error) => resume(Effect.fail(error)));
+      server.listen(callbackPort, "localhost", () => resume(Effect.void));
+    });
+    yield* Effect.addFinalizer(() => Effect.sync(() => server.close()));
+    return {
+      mode: "auto",
+      url: authorizeURL(redirect, pkce, state),
+      instructions: "Complete authorization in your browser. This window will close automatically.",
+      callback: Deferred.await(code).pipe(Effect.flatMap((value) => exchange(value, redirect, pkce, app)), Effect.map((tokens) => credential(browserMethodID, tokens)))
+    };
+  }),
+  refresh: (value) => refresh(browserMethodID, value, app)
+});
+var headless = (app) => ({
+  integrationID: exports_integration.ID.make("openai"),
+  method: {
+    id: headlessMethodID,
+    type: "oauth",
+    label: "ChatGPT Pro/Plus (headless)"
+  },
+  authorize: () => Effect.gen(function* () {
+    const device = yield* request(`${issuer}/api/accounts/deviceauth/usercode`, {
+      method: "POST",
+      headers: headers("application/json", app),
+      body: JSON.stringify({ client_id: clientID })
+    });
+    const interval = Math.max(Number.parseInt(device.interval) || 5, 1) * 1000;
+    return {
+      mode: "auto",
+      url: `${issuer}/codex/device`,
+      instructions: `Enter code: ${device.user_code}`,
+      callback: Effect.gen(function* () {
+        while (true) {
+          const response = yield* Effect.tryPromise({
+            try: (signal) => fetch(`${issuer}/api/accounts/deviceauth/token`, {
+              method: "POST",
+              headers: headers("application/json", app),
+              body: JSON.stringify({ device_auth_id: device.device_auth_id, user_code: device.user_code }),
+              signal
+            }),
+            catch: (cause) => cause
+          });
+          if (response.ok) {
+            const data = yield* Effect.promise(() => response.json());
+            return credential(headlessMethodID, yield* exchange(data.authorization_code, `${issuer}/deviceauth/callback`, { verifier: data.code_verifier, challenge: "" }, app));
+          }
+          if (response.status !== 403 && response.status !== 404) {
+            return yield* Effect.fail(new Error(`Device authorization failed: ${response.status}`));
+          }
+          yield* Effect.sleep(interval + pollingSafetyMargin);
+        }
+      })
+    };
+  }),
+  refresh: (value) => refresh(headlessMethodID, value, app)
+});
+var OpenAIPlugin = define({
+  id: "opencode.provider.openai",
+  effect: Effect.fn(function* (ctx) {
+    const bus = yield* exports_bus.Service;
+    const loading = Semaphore.makeUnsafe(1);
+    let chatgpt;
+    const load = Effect.fn("OpenAIPlugin.load")(function* () {
+      const connection = yield* ctx.integration.connection.active("openai");
+      const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.catch(() => Effect.succeed(undefined))) : undefined;
+      chatgpt = credential?.type === "oauth" && (credential.methodID === browserMethodID || credential.methodID === headlessMethodID) ? credential : undefined;
+    });
+    yield* ctx.integration.transform((draft) => {
+      draft.method.update(browser(ctx.app));
+      draft.method.update(headless(ctx.app));
+    });
+    yield* load();
+    yield* ctx.catalog.transform((evt) => {
+      for (const item2 of evt.provider.list()) {
+        if (!exports_provider.isAISDK(item2.provider.package))
+          continue;
+        if (exports_provider.packageName(item2.provider.package) !== "@ai-sdk/openai")
+          continue;
+        evt.provider.update(item2.provider.id, (provider) => {
+          provider.package = "@opencode-ai/ai/providers/openai";
+        });
+      }
+      if (!chatgpt)
+        return;
+      const item = evt.provider.get(exports_provider.ID.openai);
+      if (!item)
+        return;
+      item.provider.settings = exports_provider.mergeOverlay(item.provider.settings, { baseURL: codexBaseURL });
+      const account = chatgpt.metadata?.accountID;
+      item.provider.headers = exports_provider.mergeHeaders(item.provider.headers, {
+        originator: "opencode",
+        ...typeof account === "string" ? { "chatgpt-account-id": account } : {}
+      });
+      for (const model of item.models.values()) {
+        evt.model.update(item.provider.id, model.id, (draft) => {
+          if (Schema.is(Schema.Struct({ mode: Schema.Literal("pro") }))(draft.body?.reasoning)) {
+            draft.enabled = false;
+            return;
+          }
+          const apiID = draft.modelID ?? draft.id;
+          const match = apiID.match(/^gpt-(\d+\.\d+)/);
+          if (!codexAllowed.has(apiID) && (codexDisallowed.has(apiID) || !match || Number.parseFloat(match[1]) <= 5.4)) {
+            draft.enabled = false;
+            return;
+          }
+          draft.cost = [];
+          draft.limit = { ...draft.limit, context: 400000, input: 272000 };
+        });
+      }
+    });
+    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
+    yield* bus.subscribe(exports_integration.Event.ConnectionUpdated).pipe(Stream.filter((event) => event.data.integrationID === exports_integration.ID.make("openai")), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+function headers(contentType, app) {
+  return { "Content-Type": contentType, "User-Agent": exports_app.useragent(app) };
+}
+function exchange(code, redirect, pkce, app) {
+  return request(`${issuer}/oauth/token`, {
+    method: "POST",
+    headers: headers("application/x-www-form-urlencoded", app),
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: redirect,
+      client_id: clientID,
+      code_verifier: pkce.verifier
+    }).toString()
+  });
+}
+function refresh(methodID, value, app) {
+  return request(`${issuer}/oauth/token`, {
+    method: "POST",
+    headers: headers("application/x-www-form-urlencoded", app),
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: value.refresh,
+      client_id: clientID
+    }).toString()
+  }).pipe(Effect.map((tokens) => {
+    const next = credential(methodID, tokens);
+    return exports_credential.OAuth.make({ ...next, metadata: next.metadata ?? value.metadata });
+  }));
+}
+function request(url, init) {
+  return Effect.tryPromise({
+    try: async (signal) => {
+      const response = await fetch(url, { ...init, signal });
+      if (!response.ok)
+        throw new Error(`Request failed: ${response.status}`);
+      return response.json();
+    },
+    catch: (cause) => cause
+  });
+}
+function credential(methodID, tokens) {
+  const accountID = extractAccountID(tokens);
+  return exports_credential.OAuth.make({
+    type: "oauth",
+    methodID,
+    refresh: tokens.refresh_token,
+    access: tokens.access_token,
+    expires: Date.now() + (tokens.expires_in ?? 3600) * 1000,
+    metadata: accountID ? { accountID } : undefined
+  });
+}
+async function generatePKCE() {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
+  const verifier = Array.from(crypto.getRandomValues(new Uint8Array(43)), (byte) => chars[byte % chars.length]).join("");
+  const challenge = base64UrlEncode(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)));
+  return { verifier, challenge };
+}
+function base64UrlEncode(buffer) {
+  return Buffer.from(buffer).toString("base64url");
+}
+function authorizeURL(redirect, pkce, state) {
+  return `${issuer}/oauth/authorize?${new URLSearchParams({
+    response_type: "code",
+    client_id: clientID,
+    redirect_uri: redirect,
+    scope: "openid profile email offline_access",
+    code_challenge: pkce.challenge,
+    code_challenge_method: "S256",
+    id_token_add_organizations: "true",
+    codex_cli_simplified_flow: "true",
+    state,
+    originator: "opencode"
+  })}`;
+}
+function extractAccountID(tokens) {
+  return claim(tokens.id_token) ?? claim(tokens.access_token);
+}
+function claim(token) {
+  const part = token.split(".")[1];
+  if (!part)
+    return;
+  const claims = Option.getOrUndefined(decodeClaims(Buffer.from(part, "base64url").toString()));
+  if (!claims)
+    return;
+  return claims.chatgpt_account_id ?? claims["https://api.openai.com/auth"]?.chatgpt_account_id ?? claims.organizations?.[0]?.id;
+}
+
+export { OpenAIPlugin };

package/dist/chunks/location-mutation-faypg4r1.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260428004200_add_session_path.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260428004200_add_session_path",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`path\` text;`);
+    });
+  }
+};
+var _20260428004200_add_session_path_default = migration;
+
+export { _20260428004200_add_session_path_default };