@opencode-ai/core 0.0.0-dev-17471

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

@@ -0,0 +1,214 @@
+import {
+  WorktreeTable
+} from "./location-mutation-mh28new4.js";
+import {
+  exports_schema
+} from "./location-mutation-8v47shgf.js";
+import {
+  ProjectTable,
+  upsertProject
+} from "./location-mutation-88jbfw8z.js";
+import {
+  exports_git
+} from "./location-mutation-kcwh27nh.js";
+import {
+  AbsolutePath
+} from "./location-mutation-j07kk359.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  exports_database
+} from "./location-mutation-j0ksmf2f.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/project.ts
+var exports_project = {};
+__export(exports_project, {
+  root: () => root,
+  node: () => node,
+  Vcs: () => Vcs,
+  Service: () => Service,
+  Project: () => exports_project,
+  Info: () => Info,
+  ID: () => ID,
+  Current: () => Current
+});
+import { Context, Effect, Layer } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { and, asc, desc, eq } from "drizzle-orm";
+import path from "path";
+import { Worktree } from "@opencode-ai/schema/worktree";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { AppProcess } from "@opencode-ai/util/process";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { Hash } from "@opencode-ai/util/hash";
+var ID = exports_schema.ID;
+var Vcs = exports_schema.Vcs;
+var Current = exports_schema.Current;
+var Info = exports_schema.Info;
+var root = Effect.fn("Project.root")(function* (fs, input) {
+  return yield* fs.up({ targets: [".git", ".hg"], start: input, mode: "first" }).pipe(Effect.map((matches) => matches[0] ? AbsolutePath.make(path.dirname(matches[0])) : undefined), Effect.catch(() => Effect.succeed(undefined)));
+});
+
+class Service extends Context.Service()("@opencode/Project") {
+}
+function fromRow(row) {
+  const icon = row.icon_url || row.icon_url_override || row.icon_color ? {
+    url: row.icon_url ?? undefined,
+    override: row.icon_url_override ?? undefined,
+    color: row.icon_color ?? undefined
+  } : undefined;
+  return {
+    id: row.id,
+    canonical: row.worktree,
+    vcs: row.vcs ?? undefined,
+    name: row.name ?? undefined,
+    icon,
+    commands: row.commands ?? undefined,
+    time: {
+      created: row.time_created,
+      updated: row.time_updated,
+      initialized: row.time_initialized ?? undefined
+    },
+    sandboxes: row.sandboxes
+  };
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const git = yield* exports_git.Service;
+  const proc = yield* AppProcess.Service;
+  const bus = yield* exports_bus.Service;
+  const db = (yield* exports_database.Service).db;
+  const announcing = new Set;
+  const persist = Effect.fnUntraced(function* (project) {
+    yield* upsertProject(db, project).pipe(Effect.orDie);
+    if (!project.vcs)
+      return project;
+    const directories = [
+      { projectID: project.id, directory: project.canonical }
+    ];
+    if (project.directory !== project.canonical)
+      directories.push({
+        projectID: project.id,
+        directory: project.directory,
+        strategy: project.vcs.type === "git" ? "git" : undefined
+      });
+    for (const item of directories) {
+      const key = item.projectID + "\x00" + item.directory;
+      if (announcing.has(key))
+        continue;
+      announcing.add(key);
+      yield* Effect.gen(function* () {
+        const stored = yield* db.select({ directory: WorktreeTable.directory }).from(WorktreeTable).where(and(eq(WorktreeTable.project_id, item.projectID), eq(WorktreeTable.directory, item.directory))).get().pipe(Effect.orDie);
+        if (stored)
+          return;
+        yield* bus.publish(Worktree.Event.Resolved, { projectID: item.projectID, directory: item.directory, previous: project.previous ?? ID.global }, {
+          commit: () => db.insert(WorktreeTable).values({ project_id: item.projectID, directory: item.directory, strategy: item.strategy }).onConflictDoNothing().run().pipe(Effect.orDie, Effect.asVoid)
+        });
+      }).pipe(Effect.ensuring(Effect.sync(() => announcing.delete(key))));
+    }
+    return project;
+  });
+  const list = Effect.fn("Project.list")(function* () {
+    const rows = yield* db.select().from(ProjectTable).orderBy(desc(ProjectTable.time_updated), asc(ProjectTable.id)).all().pipe(Effect.orDie);
+    return rows.map(fromRow);
+  });
+  const cached = Effect.fnUntraced(function* (dir) {
+    return yield* fs.readFileString(path.join(dir, "opencode")).pipe(Effect.map((value) => value.trim()), Effect.map((value) => value ? ID.make(value) : undefined), Effect.catch(() => Effect.succeed(undefined)));
+  });
+  const remote = Effect.fnUntraced(function* (repo) {
+    const origin = yield* git.remote.get(repo);
+    if (!origin)
+      return;
+    const normalized = url(origin);
+    if (!normalized)
+      return;
+    return ID.make(Hash.fast(`git-remote:${normalized}`));
+  });
+  function url(input) {
+    const value = input.trim();
+    if (!value)
+      return;
+    try {
+      const parsed = new URL(value);
+      if (parsed.protocol === "file:")
+        return;
+      return parts(parsed.hostname, parsed.pathname);
+    } catch {
+      const scp = value.match(/^([^@/:]+@)?([^/:]+):(.+)$/);
+      if (scp)
+        return parts(scp[2], scp[3]);
+      return;
+    }
+  }
+  function parts(host, name) {
+    const pathname = name.replace(/^\/+/, "").replace(/\.git\/?$/, "").replace(/\/+$/, "");
+    if (!host || !pathname)
+      return;
+    return `${host.toLowerCase()}/${pathname}`;
+  }
+  const root2 = Effect.fnUntraced(function* (repo) {
+    const root3 = (yield* git.history.rootCommits(repo))[0];
+    return root3 ? ID.make(root3) : undefined;
+  });
+  const hgRoot = Effect.fnUntraced(function* (worktree) {
+    const result = yield* proc.run(ChildProcess.make("hg", ["log", "-r", "roots(all())", "-T", `{node}
+`], {
+      cwd: worktree,
+      env: { HGPLAIN: "1" },
+      extendEnv: true,
+      stdin: "ignore"
+    })).pipe(Effect.catch(() => Effect.succeed(undefined)));
+    if (!result || result.exitCode !== 0)
+      return;
+    const node = result.stdout.toString("utf8").split(`
+`).map((item) => item.trim()).filter(Boolean).toSorted()[0];
+    return node ? ID.make(node) : undefined;
+  });
+  const hgDiscover = Effect.fnUntraced(function* (input) {
+    const dotHg = yield* fs.up({ targets: [".hg"], start: input, mode: "first" }).pipe(Effect.map((matches) => matches[0]), Effect.catch(() => Effect.succeed(undefined)));
+    if (!dotHg)
+      return;
+    const worktree = AbsolutePath.make(path.dirname(dotHg));
+    const store = AbsolutePath.make(dotHg);
+    const previous = yield* cached(store);
+    const id = previous ?? (yield* hgRoot(worktree));
+    return {
+      previous,
+      id: id ?? ID.global,
+      directory: worktree,
+      vcs: { type: "hg", store }
+    };
+  });
+  const resolve = Effect.fn("Project.resolve")(function* (input) {
+    const repo = yield* git.repo.discover(input);
+    if (repo) {
+      const previous = yield* cached(repo.commonDirectory);
+      const id = (yield* remote(repo)) ?? previous ?? (yield* root2(repo));
+      const canonical = repo.gitDirectory === repo.commonDirectory ? repo.worktree : yield* git.worktree.list(repo).pipe(Effect.map((items) => items.find((item) => item.kind === "main")?.directory ?? repo.worktree), Effect.catch(() => Effect.succeed(repo.worktree)));
+      return yield* persist({
+        previous,
+        id: id ?? ID.global,
+        directory: repo.worktree,
+        canonical,
+        vcs: { type: "git", store: repo.commonDirectory }
+      });
+    }
+    const hg = yield* hgDiscover(input);
+    if (hg)
+      return yield* persist({ ...hg, canonical: hg.directory });
+    const directory = AbsolutePath.make(path.parse(input).root);
+    return yield* persist({ id: ID.global, directory, canonical: directory, vcs: undefined });
+  });
+  return Service.of({ list, resolve });
+}));
+var node = makeGlobalNode({
+  service: Service,
+  layer,
+  deps: [exports_bus.node, exports_database.node, FSUtil.node, exports_git.node, AppProcess.node]
+});
+
+export { ID, Vcs, Current, Info, root, Service, node, exports_project };

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

@@ -0,0 +1,13 @@
+// src/database/migration/20260507164347_add_workspace_time.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260507164347_add_workspace_time",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`time_used\` integer NOT NULL DEFAULT 0;`);
+    });
+  }
+};
+var _20260507164347_add_workspace_time_default = migration;
+
+export { _20260507164347_add_workspace_time_default };

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

@@ -0,0 +1,8 @@
+// src/database/schema.sql.ts
+import { integer } from "drizzle-orm/sqlite-core";
+var Timestamps = {
+  time_created: integer().notNull().$default(() => Date.now()),
+  time_updated: integer().notNull().$onUpdate(() => Date.now())
+};
+
+export { Timestamps };

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

@@ -0,0 +1,18 @@
+import {
+  createProviderPlugin
+} from "./location-mutation-0zz82cjq.js";
+import {
+  __require
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/provider/gateway.ts
+var GatewayPlugin = createProviderPlugin({
+  id: "opencode.provider.gateway",
+  package: "@ai-sdk/gateway",
+  load: async (options) => {
+    const { createGateway } = await import("@ai-sdk/gateway");
+    return createGateway(options);
+  }
+});
+
+export { GatewayPlugin };

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

@@ -0,0 +1,251 @@
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/aisdk-native.ts
+var exports_aisdk_native = {};
+__export(exports_aisdk_native, {
+  map: () => map,
+  AISDKNative: () => exports_aisdk_native
+});
+import { isRecord } from "@opencode-ai/ai/utils/record";
+function map(input) {
+  const baseSettings = mapBaseSettings(input.settings);
+  switch (input.packageName) {
+    case "@ai-sdk/amazon-bedrock":
+      return {
+        package: "@opencode-ai/ai/providers/amazon-bedrock",
+        settings: mapBedrockSettings(input.settings, baseSettings),
+        ...mapBedrockRequest(input)
+      };
+    case "@ai-sdk/amazon-bedrock/mantle":
+      return mapBedrockMantle(input, baseSettings);
+    case "@ai-sdk/azure":
+      return {
+        package: `@opencode-ai/ai/providers/azure/${input.settings.useCompletionUrls === true ? "chat" : "responses"}`,
+        settings: {
+          ...baseSettings,
+          ...mapAPIKey(input.settings),
+          ...typeof input.settings.resourceName === "string" ? { resourceName: input.settings.resourceName } : {},
+          ...typeof input.settings.apiVersion === "string" ? { apiVersion: input.settings.apiVersion } : {},
+          ...isStringRecord(input.settings.queryParams) ? { queryParams: input.settings.queryParams } : {},
+          ...typeof input.settings.useDeploymentBasedUrls === "boolean" ? { useDeploymentBasedUrls: input.settings.useDeploymentBasedUrls } : {},
+          ...mapOpenAIOptions(input.settings)
+        }
+      };
+    case "@ai-sdk/google":
+      return {
+        package: "@opencode-ai/ai/providers/google",
+        settings: {
+          ...baseSettings,
+          ...mapAPIKey(input.settings),
+          ...mapGoogleOptions(input.settings)
+        }
+      };
+    case "@ai-sdk/google-vertex/anthropic":
+      return {
+        package: "@opencode-ai/ai/providers/google-vertex/messages",
+        settings: {
+          ...baseSettings,
+          ...typeof input.settings.accessToken === "string" ? { accessToken: input.settings.accessToken } : {},
+          ...typeof input.settings.location === "string" ? { location: input.settings.location } : {},
+          ...typeof input.settings.project === "string" ? { project: input.settings.project } : {},
+          ...isRecord(input.settings.thinking) || typeof input.settings.effort === "string" ? {
+            providerOptions: {
+              anthropic: {
+                ...isRecord(input.settings.thinking) ? { thinking: input.settings.thinking } : {},
+                ...typeof input.settings.effort === "string" ? { effort: input.settings.effort } : {}
+              }
+            }
+          } : {}
+        },
+        ...isStringRecord(input.settings.headers) ? { headers: input.settings.headers } : {}
+      };
+    case "@openrouter/ai-sdk-provider":
+      return mapOpenRouter(input.settings, baseSettings);
+    case "@ai-sdk/xai":
+      return {
+        package: "@opencode-ai/ai/providers/xai",
+        settings: {
+          ...baseSettings,
+          ...mapAPIKey(input.settings),
+          ...mapXAIOptions(input.settings)
+        }
+      };
+  }
+}
+function mapBedrockMantle(input, baseSettings) {
+  const settings = input.settings;
+  const chat = input.modelID === "openai.gpt-oss-safeguard-20b" || input.modelID === "openai.gpt-oss-safeguard-120b";
+  return {
+    package: `@opencode-ai/ai/providers/amazon-bedrock/mantle/${chat ? "chat" : "responses"}`,
+    settings: {
+      ...mapBedrockSettings(settings, baseSettings),
+      ...mapOpenAIOptions(settings)
+    },
+    ...isStringRecord(settings.headers) ? { headers: settings.headers } : {}
+  };
+}
+function mapBedrockSettings(settings, baseSettings) {
+  const apiKey = typeof settings.apiKey === "string" ? settings.apiKey : typeof settings.bearerToken === "string" ? settings.bearerToken : undefined;
+  const region = bedrockRegion(settings);
+  const credentials = mapBedrockCredentials(settings, region);
+  return {
+    ...baseSettings,
+    ...typeof baseSettings.baseURL === "string" && region !== undefined ? { baseURL: baseSettings.baseURL.replaceAll("${AWS_REGION}", region) } : {},
+    ...typeof settings.baseURL !== "string" && typeof settings.endpoint === "string" ? { baseURL: settings.endpoint } : {},
+    ...apiKey === undefined ? {} : { apiKey },
+    ...credentials === undefined ? {} : { credentials },
+    ...typeof settings.region === "string" ? { region: settings.region } : {},
+    ...typeof settings.topP === "number" ? { topP: settings.topP } : {}
+  };
+}
+function mapBedrockRequest(input) {
+  const settings = input.settings;
+  const headers = isStringRecord(settings.headers) ? settings.headers : undefined;
+  const additional = isRecord(settings.additionalModelRequestFields) ? settings.additionalModelRequestFields : {};
+  const reasoning = isRecord(settings.reasoningConfig) ? settings.reasoningConfig : undefined;
+  const anthropic = input.modelID.includes("anthropic");
+  const openai = input.modelID.startsWith("openai.");
+  const effort = typeof reasoning?.maxReasoningEffort === "string" ? reasoning.maxReasoningEffort : undefined;
+  const type = typeof reasoning?.type === "string" ? reasoning.type : undefined;
+  const budget = typeof reasoning?.budgetTokens === "number" ? reasoning.budgetTokens : undefined;
+  const display = typeof reasoning?.display === "string" ? reasoning.display : undefined;
+  const betas = Array.isArray(settings.anthropicBeta) ? settings.anthropicBeta.filter((item) => typeof item === "string") : [];
+  const existingBetas = Array.isArray(additional.anthropic_beta) ? additional.anthropic_beta.filter((item) => typeof item === "string") : [];
+  const fields = exports_provider.mergeOverlay(additional, {
+    ...betas.length > 0 ? { anthropic_beta: [...existingBetas, ...betas] } : {},
+    ...anthropic && type === "enabled" && budget !== undefined ? { thinking: { type: "enabled", budget_tokens: budget } } : {},
+    ...anthropic && type === "adaptive" ? { thinking: { type: "adaptive", ...display === undefined ? {} : { display } } } : {},
+    ...anthropic && effort !== undefined ? {
+      output_config: {
+        ...isRecord(additional.output_config) ? additional.output_config : {},
+        effort
+      }
+    } : {},
+    ...!anthropic && openai && effort !== undefined ? { reasoning_effort: effort } : {},
+    ...!anthropic && !openai && effort !== undefined ? {
+      reasoningConfig: {
+        ...type === undefined || type === "adaptive" ? {} : { type },
+        ...budget === undefined ? {} : { budgetTokens: budget },
+        maxReasoningEffort: effort
+      }
+    } : {}
+  });
+  const body = {
+    ...fields && Object.keys(fields).length > 0 ? { additionalModelRequestFields: fields } : {},
+    ...typeof settings.serviceTier === "string" ? { serviceTier: { type: settings.serviceTier } } : {}
+  };
+  return {
+    ...headers === undefined ? {} : { headers },
+    ...Object.keys(body).length === 0 ? {} : { body }
+  };
+}
+function mapBedrockCredentials(settings, region) {
+  const credentials = isRecord(settings.credentials) ? settings.credentials : settings;
+  if (region === undefined || typeof credentials.accessKeyId !== "string" || typeof credentials.secretAccessKey !== "string")
+    return;
+  return {
+    region,
+    accessKeyId: credentials.accessKeyId,
+    secretAccessKey: credentials.secretAccessKey,
+    ...typeof credentials.sessionToken === "string" ? { sessionToken: credentials.sessionToken } : {}
+  };
+}
+function bedrockRegion(settings) {
+  const credentials = isRecord(settings.credentials) ? settings.credentials : settings;
+  return typeof settings.region === "string" ? settings.region : typeof credentials.region === "string" ? credentials.region : undefined;
+}
+function mapOpenAIOptions(settings) {
+  const options = {
+    ...typeof settings.reasoningEffort === "string" ? { reasoningEffort: settings.reasoningEffort } : {},
+    ...typeof settings.reasoningSummary === "string" ? { reasoningSummary: settings.reasoningSummary } : {},
+    ...Array.isArray(settings.include) ? { include: settings.include } : {},
+    ...typeof settings.store === "boolean" ? { store: settings.store } : {},
+    ...typeof settings.promptCacheKey === "string" ? { promptCacheKey: settings.promptCacheKey } : {},
+    ...typeof settings.textVerbosity === "string" ? { textVerbosity: settings.textVerbosity } : {},
+    ...typeof settings.serviceTier === "string" ? { serviceTier: settings.serviceTier } : {}
+  };
+  if (Object.keys(options).length === 0)
+    return {};
+  return { providerOptions: { openai: options } };
+}
+function mapBaseSettings(settings) {
+  return {
+    ...typeof settings.baseURL === "string" ? { baseURL: settings.baseURL } : {}
+  };
+}
+function mapAPIKey(settings) {
+  return typeof settings.apiKey === "string" ? { apiKey: settings.apiKey } : {};
+}
+function mapGoogleOptions(settings) {
+  const input = settings.thinkingConfig;
+  const thinkingConfig = {
+    ...isRecord(input) && typeof input.thinkingBudget === "number" ? { thinkingBudget: input.thinkingBudget } : {},
+    ...isRecord(input) && typeof input.includeThoughts === "boolean" ? { includeThoughts: input.includeThoughts } : {},
+    ...isRecord(input) && typeof input.thinkingLevel === "string" ? { thinkingLevel: input.thinkingLevel } : {}
+  };
+  const options = {
+    ...typeof settings.cachedContent === "string" ? { cachedContent: settings.cachedContent } : {},
+    ...Array.isArray(settings.safetySettings) ? { safetySettings: settings.safetySettings } : {},
+    ...typeof settings.serviceTier === "string" ? { serviceTier: settings.serviceTier } : {},
+    ...Object.keys(thinkingConfig).length > 0 ? { thinkingConfig } : {}
+  };
+  if (Object.keys(options).length === 0)
+    return {};
+  return { providerOptions: { gemini: options } };
+}
+function mapOpenRouter(settings, baseSettings) {
+  const headers = exports_provider.mergeHeaders({
+    ...typeof settings.appName === "string" ? { "X-OpenRouter-Title": settings.appName } : {},
+    ...typeof settings.appUrl === "string" ? { "HTTP-Referer": settings.appUrl } : {},
+    ...isStringRecord(settings.api_keys) && Object.keys(settings.api_keys).length > 0 ? { "X-Provider-API-Keys": JSON.stringify(settings.api_keys) } : {}
+  }, isStringRecord(settings.headers) ? settings.headers : undefined) ?? {};
+  return {
+    package: "@opencode-ai/ai/providers/openrouter",
+    settings: {
+      ...baseSettings,
+      ...mapAPIKey(settings),
+      ...mapOpenRouterOptions(settings)
+    },
+    ...Object.keys(headers).length > 0 ? { headers } : {},
+    ...isRecord(settings.extraBody) ? { body: settings.extraBody } : {}
+  };
+}
+function mapOpenRouterOptions(settings) {
+  const options = Object.fromEntries(Object.entries(settings).filter(([key]) => ![
+    "apiKey",
+    "api_keys",
+    "appName",
+    "appUrl",
+    "authToken",
+    "baseURL",
+    "chunkTimeout",
+    "compatibility",
+    "extraBody",
+    "fetch",
+    "headers",
+    "promptCacheKey",
+    "timeout"
+  ].includes(key)));
+  if (Object.keys(options).length === 0)
+    return {};
+  return { providerOptions: { openrouter: options } };
+}
+function isStringRecord(value) {
+  return isRecord(value) && Object.values(value).every((item) => typeof item === "string");
+}
+function mapXAIOptions(settings) {
+  const options = {
+    ...typeof settings.reasoningEffort === "string" ? { reasoningEffort: settings.reasoningEffort } : {},
+    ...typeof settings.store === "boolean" ? { store: settings.store } : {}
+  };
+  if (Object.keys(options).length === 0)
+    return {};
+  return { providerOptions: { xai: options } };
+}
+
+export { map, exports_aisdk_native };

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

@@ -0,0 +1,52 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/id/id.ts
+var exports_id = {};
+__export(exports_id, {
+  timestamp: () => timestamp,
+  descending: () => descending,
+  create: () => createID,
+  ascending: () => ascending,
+  Identifier: () => exports_id
+});
+import { create } from "@opencode-ai/schema/identifier";
+var prefixes = {
+  job: "job",
+  event: "evt",
+  session: "ses",
+  message: "msg",
+  permission: "per",
+  question: "que",
+  part: "prt",
+  pty: "pty",
+  tool: "tool",
+  workspace: "wrk"
+};
+function ascending(prefix, given) {
+  return generateID(prefix, "ascending", given);
+}
+function descending(prefix, given) {
+  return generateID(prefix, "descending", given);
+}
+function generateID(prefix, direction, given) {
+  if (!given) {
+    return createID(prefixes[prefix], direction);
+  }
+  if (!given.startsWith(prefixes[prefix])) {
+    throw new Error(`ID ${given} does not start with ${prefixes[prefix]}`);
+  }
+  return given;
+}
+function createID(prefix, direction, timestamp) {
+  return prefix + "_" + create(direction === "descending", timestamp);
+}
+function timestamp(id) {
+  const prefix = id.split("_")[0];
+  const hex = id.slice(prefix.length + 1, prefix.length + 13);
+  const encoded = BigInt("0x" + hex);
+  return Number(encoded / BigInt(4096));
+}
+
+export { ascending, descending, createID, timestamp, exports_id };

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

@@ -0,0 +1,83 @@
+import {
+  exports_mcp
+} from "./location-mutation-1c00jchy.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/websearch/exa.ts
+var exports_exa = {};
+__export(exports_exa, {
+  endpoint: () => endpoint,
+  WebSearchExa: () => exports_exa,
+  Plugin: () => Plugin
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+var endpoint = "https://mcp.exa.ai/mcp";
+var McpInput = Schema.Struct({
+  query: Schema.String,
+  numResults: Schema.Number.pipe(Schema.optional)
+});
+var McpOutput = Schema.Struct({
+  content: Schema.Array(Schema.Struct({
+    type: Schema.Literal("text"),
+    text: Schema.String,
+    _meta: Schema.Struct({ searchTime: Schema.Number }).pipe(Schema.optional)
+  }))
+});
+var Plugin = define({
+  id: "opencode.websearch.exa",
+  effect: Effect.fn("WebSearchExa.Plugin")(function* (ctx) {
+    const http = yield* HttpClient.HttpClient;
+    yield* ctx.integration.transform((draft) => {
+      draft.update("exa", (integration) => integration.name = "Exa");
+      draft.method.update({
+        integrationID: "exa",
+        method: { type: "key" }
+      });
+      draft.method.update({
+        integrationID: "exa",
+        method: { type: "env", names: ["EXA_API_KEY"] }
+      });
+    });
+    yield* ctx.websearch.transform((draft) => {
+      draft.add({
+        id: "exa",
+        name: "Exa",
+        execute: (input) => Effect.gen(function* () {
+          const connection = yield* ctx.integration.connection.active("exa");
+          const credential = connection ? yield* ctx.integration.connection.resolve(connection) : undefined;
+          const url = new URL(endpoint);
+          if (credential?.type === "key")
+            url.searchParams.set("exaApiKey", credential.key);
+          const result = yield* exports_mcp.call(http, url.toString(), "web_search_exa", { input: McpInput, output: McpOutput }, { query: input.query, numResults: 8 });
+          const content = result?.content.find((item) => item.text);
+          return content ? parseResults(content.text) : [];
+        })
+      });
+    });
+  })
+});
+function parseResults(text) {
+  return text.split(/\n\n---\n\n/).flatMap((block) => {
+    const url = block.match(/^URL:\s*(.+)$/m)?.[1]?.trim();
+    if (!url)
+      return [];
+    const title = block.match(/^Title:\s*(.+)$/m)?.[1]?.trim();
+    const publishedText = block.match(/^Published:\s*(.+)$/m)?.[1]?.trim();
+    const published = publishedText && publishedText !== "N/A" ? Date.parse(publishedText) : undefined;
+    const content = block.match(/^(?:Highlights|Text):\s*\n?([\s\S]*)$/m)?.[1]?.trim();
+    return [
+      {
+        url,
+        ...title && title !== "N/A" ? { title } : {},
+        ...content ? { content } : {},
+        time: { ...published !== undefined && Number.isFinite(published) ? { published } : {} }
+      }
+    ];
+  });
+}
+
+export { endpoint, Plugin, exports_exa };

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

@@ -0,0 +1,21 @@
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/v1/config/command.ts
+var exports_command = {};
+__export(exports_command, {
+  Info: () => Info,
+  ConfigCommandV1: () => exports_command
+});
+import { Schema } from "effect";
+var Info = Schema.Struct({
+  template: Schema.String,
+  description: Schema.optional(Schema.String),
+  agent: Schema.optional(Schema.String),
+  model: Schema.optional(Schema.String),
+  variant: Schema.optional(Schema.String),
+  subtask: Schema.optional(Schema.Boolean)
+});
+
+export { Info, exports_command };