@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-zf4nb4wp.js

@@ -0,0 +1,272 @@
+import {
+  ID12,
+  isAISDK2,
+  packageName2,
+  loadPackage2,
+  mergeOverlay2,
+  mergeHeaders2
+} from "./worktree-9qn3qky1.js";
+import {
+  Service62,
+  node67
+} from "./worktree-b1x7x3xx.js";
+import {
+  map2
+} from "./worktree-a4r18kjz.js";
+import {
+  ID11,
+  VariantID2,
+  Ref3
+} from "./worktree-esam66tc.js";
+import {
+  ID8,
+  Service64,
+  node69
+} from "./worktree-g0he3e83.js";
+import {
+  Service63,
+  node68
+} from "./worktree-e3fx731j.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/model-resolver.ts
+var exports_model_resolver = {};
+__export(exports_model_resolver, {
+  ModelResolver: () => exports_model_resolver,
+  Service: () => Service61,
+  UnresolvedProviderVariablesError: () => UnresolvedProviderVariablesError3,
+  UnsupportedCompactionError: () => UnsupportedCompactionError3,
+  UnsupportedPackageError: () => UnsupportedPackageError3,
+  VariantUnavailableError: () => VariantUnavailableError3,
+  fromCatalogModel: () => fromCatalogModel2,
+  hasPackage: () => hasPackage2,
+  layer: () => layer23,
+  node: () => node66,
+  resolveModel: () => resolveModel2,
+  withVariant: () => withVariant2
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { LanguageModel } from "@opencode/ai";
+import { Auth } from "@opencode/ai/route";
+import { Context, Effect, Layer, Schema, Struct } from "effect";
+import { Npm } from "@opencode/util/npm";
+class VariantUnavailableError3 extends Schema.TaggedError()("SessionRunnerModel.VariantUnavailableError", {
+  providerID: ID12,
+  modelID: ID11,
+  variant: VariantID2
+}) {
+  get message() {
+    return `Variant unavailable for ${this.providerID}/${this.modelID}: ${this.variant}`;
+  }
+}
+
+class UnsupportedPackageError3 extends Schema.TaggedError()("SessionRunnerModel.UnsupportedPackageError", {
+  providerID: ID12,
+  modelID: ID11,
+  package: Schema.String
+}) {
+  get message() {
+    return `Unsupported package for ${this.providerID}/${this.modelID}: ${this.package}`;
+  }
+}
+
+class UnresolvedProviderVariablesError3 extends Schema.TaggedError()("SessionRunnerModel.UnresolvedProviderVariablesError", {
+  providerID: ID12,
+  modelID: ID11,
+  variables: Schema.Array(Schema.String)
+}) {
+  get message() {
+    return `Cannot initialize ${this.providerID}/${this.modelID}: ${this.variables.join(", ")} ${this.variables.length === 1 ? "is" : "are"} required to resolve the provider endpoint`;
+  }
+}
+
+class UnsupportedCompactionError3 extends Schema.TaggedError()("SessionRunnerModel.UnsupportedCompactionError", {
+  providerID: ID12,
+  modelID: ID11,
+  route: Schema.String
+}) {
+  get message() {
+    return `Provider compaction is not supported by ${this.providerID}/${this.modelID} (${this.route})`;
+  }
+}
+
+class Service61 extends Context.Service()("@opencode/ModelResolver") {
+}
+var withVariant2 = (model, variantID) => {
+  const id = variantID === "default" ? undefined : variantID;
+  const variant = model.variants?.find((item) => item.id === id);
+  if (!variant && id !== undefined)
+    return Effect.fail(new VariantUnavailableError3({
+      providerID: model.providerID,
+      modelID: model.id,
+      variant: id
+    }));
+  return Effect.succeed(variant ? {
+    ...model,
+    settings: mergeOverlay2(model.settings, variant.settings),
+    headers: mergeHeaders2(model.headers, variant.headers),
+    body: mergeOverlay2(model.body, variant.body)
+  } : model);
+};
+var fromCatalogModel2 = (model, credential, dependencies) => resolveCatalogModel(model, credential, dependencies).pipe(Effect.flatMap((resolved) => validateProviderVariables(model, resolved)), Effect.flatMap((resolved) => {
+  if (model.compaction?.mode !== "provider" || resolved.route.compact?.trigger || resolved.route.compact?.endpoint)
+    return Effect.succeed(resolved);
+  return Effect.fail(new UnsupportedCompactionError3({ providerID: model.providerID, modelID: model.id, route: resolved.route.id }));
+}));
+var resolveCatalogModel = Effect.fn("ModelResolver.resolveCatalogModel")(function* (model, credential, dependencies) {
+  const resolved = prepareRuntimeModel(model, credential);
+  const packageName = packageName2(resolved.package);
+  const configuration = credential?.type === "key" ? credential.configuration : undefined;
+  const configured = { ...resolved.settings, ...credential?.metadata, ...configuration };
+  const mapping = isAISDK2(resolved.package) ? map2({
+    packageName,
+    settings: configured,
+    modelID: resolved.modelID ?? resolved.id,
+    providerID: resolved.canonical ?? resolved.providerID
+  }) : undefined;
+  const native = mapping?.package ?? packageName;
+  if (isAISDK2(resolved.package) && !mapping) {
+    const loadAISDK = dependencies?.loadAISDK;
+    if (!loadAISDK)
+      return yield* unsupported(resolved);
+    const settings = yield* prepareProviderSettings(resolved, mergeOverlay2(resolved.settings, {
+      ...nativeCredentialSettings(resolved.package ?? "", credential),
+      ...credential?.metadata,
+      ...configuration
+    }) ?? {});
+    return yield* loadAISDK({ ...resolved, settings }).pipe(Effect.mapError(() => unsupported(resolved)));
+  }
+  if (!native)
+    return yield* unsupported(resolved);
+  const specifier = native;
+  const mapped = yield* prepareProviderSettings(resolved, mapping?.settings ?? configured);
+  const module = yield* (dependencies?.loadPackage ?? loadPackage2)(specifier).pipe(Effect.mapError(() => unsupported(resolved)));
+  const settings = {
+    ...credential ? Struct.omit(mapped, ["accessToken", "apiKey", "authToken"]) : mapped,
+    ...resolved.canonical === undefined ? {} : { provider: resolved.canonical },
+    ...nativeCredentialSettings(specifier, credential),
+    headers: mergeHeaders2(mapping?.headers, resolved.headers),
+    body: mergeOverlay2(mapping?.body, resolved.body)
+  };
+  return yield* Effect.try({
+    try: () => {
+      const runtime = module.model(resolved.modelID ?? resolved.id, settings);
+      return LanguageModel.update(runtime, {
+        provider: resolved.canonical ?? resolved.providerID,
+        compatibility: resolved.compatibility ? Object.assign({}, runtime.compatibility, resolved.compatibility) : runtime.compatibility
+      });
+    },
+    catch: () => unsupported(resolved)
+  });
+});
+function prepareRuntimeModel(model, credential) {
+  if (model.settings?.apiKey !== "" && (credential?.type !== "key" || credential.metadata === undefined))
+    return model;
+  return {
+    ...model,
+    ...model.settings?.apiKey === "" ? { settings: Struct.omit(model.settings, ["apiKey"]) } : {},
+    ...credential?.type === "key" && credential.metadata !== undefined ? { body: mergeOverlay2(model.body, credential.metadata) } : {}
+  };
+}
+function validateProviderVariables(model, resolved) {
+  const baseURL = resolved.route.endpoint.baseURL;
+  if (typeof baseURL !== "string")
+    return Effect.succeed(resolved);
+  const failure = unresolvedProviderVariables(model, baseURL);
+  return failure ? Effect.fail(failure) : Effect.succeed(resolved);
+}
+function prepareProviderSettings(model, settings) {
+  const baseURL = settings.baseURL;
+  if (typeof baseURL !== "string")
+    return Effect.succeed(settings);
+  return prepareProviderURL(model, baseURL).pipe(Effect.map((prepared) => prepared === baseURL ? settings : { ...settings, baseURL: prepared }));
+}
+function prepareProviderURL(model, baseURL) {
+  if (!baseURL.includes("${"))
+    return Effect.succeed(baseURL);
+  const prepared = baseURL.replace(/\$\{([^}]+)\}/g, (placeholder, name) => process.env[name] ?? placeholder);
+  const failure = unresolvedProviderVariables(model, prepared);
+  return failure ? Effect.fail(failure) : Effect.succeed(prepared);
+}
+function unresolvedProviderVariables(model, baseURL) {
+  const variables = new Set(Array.from(baseURL.matchAll(/\$\{([^}]+)\}/g), (match) => match[1]));
+  if (variables.size === 0)
+    return;
+  return new UnresolvedProviderVariablesError3({
+    providerID: model.providerID,
+    modelID: model.id,
+    variables: Array.from(variables)
+  });
+}
+var nativeCredentialSettings = (specifier, credential) => {
+  if (!credential)
+    return {};
+  if (credential.type === "key")
+    return { apiKey: credential.key };
+  if (specifier === "@opencode/ai/providers/anthropic" || specifier === "@opencode/ai/providers/anthropic-compatible")
+    return { authToken: credential.access };
+  if (specifier === "@opencode/ai/providers/google-vertex" || specifier.startsWith("@opencode/ai/providers/google-vertex/"))
+    return { accessToken: credential.access };
+  return { apiKey: credential.access };
+};
+var unsupported = (model) => new UnsupportedPackageError3({
+  providerID: model.providerID,
+  modelID: model.id,
+  package: model.package ?? "unknown"
+});
+var resolveModel2 = (model, variant, credential, dependencies) => withVariant2(model, variant).pipe(Effect.flatMap((model) => fromCatalogModel2(model, credential, dependencies)));
+var hasPackage2 = (model) => Boolean(model.package);
+var layer23 = Layer.effect(Service61, Effect.gen(function* () {
+  const catalog = yield* Service63;
+  const integrations = yield* Service64;
+  const npm = yield* Npm.Service;
+  const aisdk = yield* Service62;
+  const load = Effect.fn("ModelResolver.resolveModel")(function* (selected, variant) {
+    const provider = yield* catalog.provider.get(selected.providerID);
+    const connection = yield* integrations.connection.active(provider?.integrationID ?? ID8.make(selected.providerID));
+    const credential = connection ? yield* integrations.connection.resolve(connection) : undefined;
+    const runtimeInfo = yield* withVariant2(selected, variant);
+    const model = yield* fromCatalogModel2(runtimeInfo, credential, {
+      loadPackage: (specifier) => loadPackage2(specifier, npm),
+      loadAISDK: (model) => aisdk.model(model)
+    });
+    const runtime = provider?.activation === "enabled" && credential === undefined && !hasConfiguredAuth(runtimeInfo) && usesAPIKeyAuth(runtimeInfo.package) ? LanguageModel.update(model, { route: model.route.with({ auth: Auth.none }) }) : model;
+    return {
+      model: runtime,
+      ref: Ref3.make({
+        id: selected.id,
+        providerID: selected.providerID,
+        ...variant === undefined ? {} : { variant }
+      }),
+      capabilities: selected.capabilities,
+      cost: selected.cost,
+      limit: selected.limit,
+      compaction: selected.compaction
+    };
+  });
+  return Service61.of({
+    resolve: Effect.fn("ModelResolver.resolve")(function* (requested) {
+      const selected = requested ? yield* catalog.model.get(requested.providerID, requested.id) : yield* catalog.model.default().pipe(Effect.flatMap((model) => model && hasPackage2(model) ? Effect.succeed(model) : Effect.map(catalog.model.available(), (models) => models.find(hasPackage2))));
+      if (!selected)
+        return;
+      return yield* load(selected, requested?.variant);
+    }),
+    resolveModel: load
+  });
+}));
+function hasConfiguredAuth(model) {
+  return [model.settings?.apiKey, model.settings?.authToken, model.settings?.accessToken].some((value) => typeof value === "string" && value !== "");
+}
+function usesAPIKeyAuth(packageName) {
+  const name = packageName2(packageName);
+  return name === "@ai-sdk/openai" || name === "@ai-sdk/anthropic" || name === "@ai-sdk/cerebras" || name === "@ai-sdk/deepinfra" || name === "@ai-sdk/openai-compatible" || name === "@ai-sdk/google" || name === "@ai-sdk/groq" || name === "@ai-sdk/mistral" || name === "@ai-sdk/togetherai" || name === "@ai-sdk/xai" || name === "@openrouter/ai-sdk-provider" || name === "@ai-sdk/azure" || name === "@opencode/ai/providers/openai" || name?.startsWith("@opencode/ai/providers/openai/") === true || name === "@opencode/ai/providers/anthropic" || name === "@opencode/ai/providers/anthropic-compatible" || name === "@opencode/ai/providers/baseten" || name === "@opencode/ai/providers/cerebras" || name === "@opencode/ai/providers/cloudflare-ai-gateway" || name === "@opencode/ai/providers/cloudflare-workers-ai" || name === "@opencode/ai/providers/deepinfra" || name === "@opencode/ai/providers/deepseek" || name === "@opencode/ai/providers/fireworks" || name === "@opencode/ai/providers/openai-compatible" || name === "@opencode/ai/providers/google" || name === "@opencode/ai/providers/groq" || name === "@opencode/ai/providers/mistral" || name === "@opencode/ai/providers/togetherai" || name === "@opencode/ai/providers/xai" || name === "@opencode/ai/providers/openrouter" || name === "@opencode/ai/providers/azure" || name?.startsWith("@opencode/ai/providers/azure/") === true;
+}
+var node66 = makeLocationNode({
+  service: Service61,
+  layer: layer23,
+  deps: [node68, node69, Npm.node, node67]
+});
+
+export { VariantUnavailableError3, UnsupportedPackageError3, UnresolvedProviderVariablesError3, UnsupportedCompactionError3, Service61, withVariant2, fromCatalogModel2, resolveModel2, hasPackage2, layer23, node66, exports_model_resolver };

package/dist/chunks/worktree-zjffjh2a.js

@@ -0,0 +1,66 @@
+import {
+  Service74,
+  node79
+} from "./worktree-z82wee6n.js";
+import {
+  Key4,
+  make21,
+  combine2
+} from "./worktree-eaj1djv9.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/instructions/builtins.ts
+var exports_builtins = {};
+__export(exports_builtins, {
+  InstructionBuiltIns: () => exports_builtins,
+  Service: () => Service28,
+  node: () => node32
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, DateTime, Effect, Layer, Schema } from "effect";
+import { Global } from "@opencode/util/global";
+class Service28 extends Context.Service()("@opencode/InstructionBuiltIns") {
+}
+var layer = Layer.effect(Service28, Effect.gen(function* () {
+  const global = yield* Global.Service;
+  const location = yield* Service74;
+  return Service28.of({
+    load: (sessionID) => Effect.succeed(combine2([
+      make21({
+        key: Key4.make("core/environment"),
+        codec: Schema.toCodecJson(Schema.String),
+        read: Effect.sync(() => [
+          "<env>",
+          `  Current conversation session ID: ${sessionID}`,
+          `  Working directory: ${location.directory}`,
+          `  Workspace root folder: ${location.project.directory}`,
+          `  Is directory a git repo: ${location.vcs?.type === "git" ? "yes" : "no"}`,
+          `  Platform: ${process.platform}`,
+          `  Prefer ${global.tmp} over generic system temporary directories such as /tmp; it is pre-created and approved for external access.`,
+          "</env>"
+        ].join(`
+`)),
+        render: {
+          initial: (environment) => ["Here is some useful information about the environment you are running in:", environment].join(`
+`),
+          changed: (_previous, environment) => ["The environment you are running in is now:", environment].join(`
+`)
+        }
+      }),
+      make21({
+        key: Key4.make("core/date"),
+        codec: Schema.toCodecJson(Schema.String),
+        read: DateTime.nowAsDate.pipe(Effect.map((date) => date.toDateString())),
+        render: {
+          initial: (date) => `Today's date: ${date}`,
+          changed: (_previous, date) => `Today's date is now: ${date}`
+        }
+      })
+    ]))
+  });
+}));
+var node32 = makeLocationNode({ service: Service28, layer, deps: [Global.node, node79] });
+
+export { Service28, node32, exports_builtins };

package/dist/chunks/worktree-zjhmce52.js

@@ -0,0 +1,79 @@
+import {
+  SQLiteEffectPreparedQuery2,
+  SQLiteEffectSession2,
+  SQLiteEffectTransaction2
+} from "./worktree-qwyrfpbr.js";
+
+// src/database/drizzle/effect-sqlite/session.ts
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Scope from "effect/Scope";
+import { entityKind } from "drizzle-orm/entity";
+function managesTransactionsNatively2(client) {
+  return client.transactionStatements === false;
+}
+
+class EffectSQLiteSession2 extends SQLiteEffectSession2 {
+  client;
+  relations;
+  options;
+  static [entityKind] = "EffectSQLiteSession";
+  constructor(client, dialect, relations, options) {
+    super(dialect);
+    this.client = client;
+    this.relations = relations;
+    this.options = options;
+  }
+  prepareQuery(query, fields, executeMethod, customResultMapper, queryMetadata, cacheConfig) {
+    return new SQLiteEffectPreparedQuery2((params, method) => this.execute(query, params, method), query, this.options.logger, this.options.cache, queryMetadata, cacheConfig, fields, executeMethod, this.options.useJitMappers, customResultMapper, undefined, undefined, this.isInTransaction());
+  }
+  prepareRelationalQuery(query, fields, executeMethod, customResultMapper, config) {
+    return new SQLiteEffectPreparedQuery2((params, method) => this.execute(query, params, method), query, this.options.logger, this.options.cache, undefined, undefined, fields, executeMethod, this.options.useJitMappers, customResultMapper, true, config, this.isInTransaction());
+  }
+  execute(query, params, method) {
+    const statement = this.client.unsafe(query.sql, params);
+    if (method === "values")
+      return statement.values.pipe(Effect.withTracerEnabled(false));
+    if (method === "get")
+      return statement.withoutTransform.pipe(Effect.map((rows) => rows[0]), Effect.withTracerEnabled(false));
+    return statement.withoutTransform.pipe(Effect.withTracerEnabled(false));
+  }
+  isInTransaction() {
+    return Effect.serviceOption(this.client.transactionService).pipe(Effect.map((option) => option._tag === "Some"));
+  }
+  executeTransactionStatement(connection, query) {
+    return connection.executeUnprepared(query, [], undefined).pipe(Effect.asVoid);
+  }
+  withTransaction(effect, config) {
+    if (managesTransactionsNatively2(this.client))
+      return this.client.withTransaction(effect);
+    return Effect.uninterruptibleMask((restore) => Effect.withFiber((fiber) => {
+      const services = fiber.context;
+      const connectionOption = Context.getOption(services, this.client.transactionService);
+      const connection = connectionOption._tag === "Some" ? Effect.succeed([undefined, connectionOption.value[0]]) : Scope.make().pipe(Effect.flatMap((scope) => Scope.provide(this.client.reserve, scope).pipe(Effect.map((connection) => [scope, connection]), Effect.catch((error) => Scope.close(scope, Exit.fail(error)).pipe(Effect.andThen(Effect.fail(error)))))));
+      const id = connectionOption._tag === "Some" ? connectionOption.value[1] + 1 : 0;
+      return connection.pipe(Effect.flatMap(([scope, connection]) => {
+        const transaction = this.executeTransactionStatement(connection, id === 0 ? `begin ${config?.behavior ?? "deferred"}` : `savepoint effect_sql_${id}`).pipe(Effect.flatMap(() => Effect.provideContext(restore(effect), Context.add(services, this.client.transactionService, [connection, id])).pipe(Effect.exit, Effect.flatMap((exit) => {
+          const finalize = Exit.isSuccess(exit) ? id === 0 ? this.executeTransactionStatement(connection, "commit").pipe(Effect.catch((error) => this.executeTransactionStatement(connection, "rollback").pipe(Effect.catch(() => Effect.void), Effect.andThen(Effect.fail(error))))) : this.executeTransactionStatement(connection, `release savepoint effect_sql_${id}`) : id === 0 ? this.executeTransactionStatement(connection, "rollback") : this.executeTransactionStatement(connection, `rollback to savepoint effect_sql_${id}`).pipe(Effect.andThen(this.executeTransactionStatement(connection, `release savepoint effect_sql_${id}`)));
+          return finalize.pipe(Effect.flatMap(() => exit));
+        }))));
+        return scope === undefined ? transaction : transaction.pipe(Effect.onExit((exit) => Scope.close(scope, exit)));
+      }));
+    }));
+  }
+  transaction(transaction, config) {
+    const { dialect, relations } = this;
+    return this.withTransaction(Effect.gen({ self: this }, function* () {
+      const tx = new EffectSQLiteTransaction2(dialect, this, relations);
+      return yield* transaction(tx);
+    }), config);
+  }
+}
+
+class EffectSQLiteTransaction2 extends SQLiteEffectTransaction2 {
+  static [entityKind] = "EffectSQLiteTransaction";
+  transaction = (tx) => this.session.transaction(tx);
+}
+
+export { managesTransactionsNatively2, EffectSQLiteSession2, EffectSQLiteTransaction2 };

package/dist/chunks/worktree-zr2ceqn5.js

@@ -0,0 +1,13 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/plugin/promise.ts
+var exports_promise = {};
+__export(exports_promise, {
+  PluginPromise: () => exports_promise,
+  fromPromise: () => fromPromise2
+});
+import { fromPromise as fromPromise2 } from "@opencode/plugin/promise/adapter";
+
+export { exports_promise, fromPromise2 };

package/dist/chunks/worktree-zxgnc9zk.js

@@ -0,0 +1,33 @@
+import {
+  isAISDK2,
+  packageName2
+} from "./worktree-9qn3qky1.js";
+
+// src/plugin/provider/nvidia.ts
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+var NvidiaPlugin2 = define({
+  id: "opencode.provider.nvidia",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!isAISDK2(item.provider.package))
+          continue;
+        if (packageName2(item.provider.package) !== "@ai-sdk/openai-compatible")
+          continue;
+        if (item.provider.settings?.baseURL !== "https://integrate.api.nvidia.com/v1")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = {
+            ...provider.headers,
+            "HTTP-Referer": "https://opencode.ai/",
+            "X-Title": "opencode",
+            "X-BILLING-INVOKE-ORIGIN": provider.headers?.["X-BILLING-INVOKE-ORIGIN"] ?? "OpenCode"
+          };
+        });
+      }
+    });
+  })
+});
+
+export { NvidiaPlugin2 };

package/dist/chunks/worktree-zxq2ej10.js

@@ -0,0 +1,34 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/plugin/source-directory.ts
+var exports_source_directory = {};
+__export(exports_source_directory, {
+  PluginSourceDirectory: () => exports_source_directory,
+  discover: () => discover2,
+  names: () => names2
+});
+import { Effect, Option } from "effect";
+import path from "path";
+var names2 = ["plugin", "plugins"];
+var discover2 = Effect.fn("PluginSourceDirectory.discover")(function* (fs, directory) {
+  const children = (yield* Effect.forEach(names2, (source) => fs.readDirectoryEntries(path.join(directory, source)).pipe(Effect.orElseSucceed(() => []), Effect.map((entries) => entries.map((entry) => ({ ...entry, target: path.join(directory, source, entry.name) })))))).flat().sort((a, b) => a.target < b.target ? -1 : a.target > b.target ? 1 : 0);
+  const targets = yield* Effect.forEach(children, (entry) => Effect.gen(function* () {
+    const source = entry.target.endsWith(".ts") || entry.target.endsWith(".js");
+    if (entry.type === "file" && source)
+      return Option.some(entry.target);
+    if (entry.type === "directory")
+      return Option.some(entry.target);
+    if (entry.type !== "symlink")
+      return Option.none();
+    if (source && (yield* fs.isFile(entry.target)))
+      return Option.some(entry.target);
+    if (yield* fs.isDir(entry.target))
+      return Option.some(entry.target);
+    return Option.none();
+  }));
+  return targets.flatMap(Option.toArray);
+});
+
+export { names2, discover2, exports_source_directory };

package/dist/chunks/worktree-zycny061.js

@@ -0,0 +1,128 @@
+import {
+  typeFollowing2
+} from "./worktree-2a5m3afh.js";
+import {
+  RelativePath2
+} from "./worktree-922hggd3.js";
+import {
+  Service74
+} from "./worktree-z82wee6n.js";
+import {
+  Service52
+} from "./worktree-pr7ch8ks.js";
+import {
+  Service45
+} from "./worktree-f8jtvgnz.js";
+import {
+  DEFAULT_SEARCH_LIMIT2,
+  DEFAULT_SEARCH_TIMEOUT_MS2,
+  GlobInput2,
+  Entry2
+} from "./worktree-neswnnnm.js";
+import {
+  Service70
+} from "./worktree-k56d8zdx.js";
+import {
+  Service69
+} from "./worktree-13bmfrpk.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/tool/plugin/glob.ts
+var exports_glob = {};
+__export(exports_glob, {
+  GlobTool: () => exports_glob,
+  Input: () => Input7,
+  Output: () => Output5,
+  Plugin: () => Plugin8,
+  name: () => name7,
+  toModelContent: () => toModelContent3
+});
+import { ToolFailure } from "@opencode/ai";
+import { Effect, Schema } from "effect";
+import path from "path";
+var name7 = "glob";
+var Input7 = Schema.Struct({
+  pattern: GlobInput2.fields.pattern.annotate({ description: "Glob pattern to match files against" }),
+  path: Schema.optionalKey(RelativePath2).annotate({
+    description: "Directory to search. Defaults to the current working directory."
+  }),
+  hidden: GlobInput2.fields.hidden.annotate({
+    description: "Include hidden files and directories (default: false)."
+  }),
+  limit: GlobInput2.fields.limit.annotate({
+    description: `Maximum number of matching files to return (default: ${DEFAULT_SEARCH_LIMIT2})`
+  })
+});
+var Output5 = Schema.Array(Entry2);
+var toModelContent3 = (entries, truncated = false) => {
+  const lines = entries.length === 0 ? ["No files found"] : entries.map((item) => item.path);
+  if (truncated)
+    lines.push("", `(Results are truncated: showing first ${entries.length} results. Consider using a more specific path or pattern.)`);
+  return lines.join(`
+`);
+};
+var Plugin8 = {
+  id: "opencode.tool.glob",
+  effect: Effect.fn("GlobTool.Plugin")(function* (ctx) {
+    const environment = yield* Service52;
+    const ripgrep = yield* Service45;
+    const location = yield* Service74;
+    const access = yield* Service69;
+    const permission = yield* Service70;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name7,
+      options: { codemode: false },
+      description: 'Search file paths using a glob pattern (examples: "**/*.ts", "src/**/*.tsx").',
+      input: Input7,
+      output: Output5,
+      execute: (input, context) => Effect.gen(function* () {
+        const searchPath = input.path === "undefined" || input.path === "null" ? undefined : input.path;
+        const source = { type: "tool", messageID: context.messageID, id: context.id };
+        const target = yield* access.resolve({ path: searchPath ?? ".", kind: "directory" });
+        yield* access.authorizeExternal([target], context);
+        yield* permission.assert({
+          action: name7,
+          resources: [input.pattern],
+          save: ["*"],
+          metadata: {
+            root: searchPath ?? ".",
+            path: searchPath,
+            hidden: input.hidden,
+            limit: input.limit
+          },
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source
+        });
+        const type = yield* typeFollowing2(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `Search path does not exist: ${searchPath ?? "."}` }))));
+        if (type !== "directory")
+          return yield* Effect.fail(new ToolFailure({ message: `Search path is not a directory: ${searchPath ?? "."}` }));
+        const root = target.absolute;
+        const limit = input.limit ?? DEFAULT_SEARCH_LIMIT2;
+        const entries = yield* ripgrep.glob({
+          cwd: root,
+          pattern: input.pattern,
+          hidden: input.hidden,
+          limit: limit + 1
+        }).pipe(Effect.timeoutOrElse({
+          duration: DEFAULT_SEARCH_TIMEOUT_MS2,
+          orElse: () => Effect.fail(new ToolFailure({
+            message: `Search timed out after ${DEFAULT_SEARCH_TIMEOUT_MS2 / 1000} seconds. Consider using a more specific path or pattern.`
+          }))
+        }), Effect.map((result) => result.map((entry) => Entry2.make({
+          ...entry,
+          path: RelativePath2.make(path.relative(location.directory, path.resolve(root, entry.path)))
+        }))));
+        return { entries: entries.slice(0, limit), truncated: entries.length > limit };
+      }).pipe(Effect.map((result) => ({
+        output: result.entries,
+        content: toModelContent3(result.entries.map((entry) => ({ ...entry, path: path.resolve(location.directory, entry.path) })), result.truncated),
+        metadata: { count: result.entries.length, truncated: result.truncated }
+      })), Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to find files matching ${input.pattern}`, error })))
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name7, Input7, Output5, toModelContent3, Plugin8, exports_glob };

package/dist/codemode/catalog.js

@@ -0,0 +1,14 @@
+import {
+  Tool2,
+  Summary2,
+  summarize2,
+  namespaceLine2,
+  exports_catalog
+} from "../chunks/worktree-3fc6dm20.js";
+export {
+  exports_catalog as CodeModeCatalog,
+  Summary2 as Summary,
+  Tool2 as Tool,
+  namespaceLine2 as namespaceLine,
+  summarize2 as summarize
+};

package/dist/codemode/instructions.js

@@ -0,0 +1,14 @@
+import {
+  render2,
+  update3,
+  make13,
+  exports_instructions3
+} from "../chunks/worktree-x1xcpfha.js";
+import"../chunks/worktree-3fc6dm20.js";
+import"../chunks/worktree-eaj1djv9.js";
+export {
+  exports_instructions3 as CodeModeInstructions,
+  make13 as make,
+  render2 as render,
+  update3 as update
+};

package/dist/codemode/tool.js

@@ -0,0 +1,11 @@
+import {
+  create2,
+  catalog2,
+  exports_tool2
+} from "../chunks/worktree-x43y2vfs.js";
+import"../chunks/worktree-3w5fmr99.js";
+export {
+  exports_tool2 as CodeModeTool,
+  catalog2 as catalog,
+  create2 as create
+};