@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-ccrec4q8.js

@@ -0,0 +1,190 @@
+import {
+  lazy2
+} from "./worktree-88xbtdfr.js";
+import {
+  load2
+} from "./worktree-paphc93g.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/filesystem/watcher.ts
+var exports_watcher = {};
+__export(exports_watcher, {
+  Event: () => Event9,
+  Native: () => Native3,
+  Options: () => Options8,
+  Service: () => Service55,
+  Test: () => Test3,
+  Watcher: () => exports_watcher,
+  configured: () => configured8,
+  hasNativeBinding: () => hasNativeBinding2,
+  layer: () => layer19,
+  nativeLayer: () => nativeLayer2,
+  nativeNode: () => nativeNode2,
+  node: () => node59,
+  testLayer: () => testLayer3
+});
+import { createWrapper } from "@parcel/watcher/wrapper";
+import { FileSystem } from "@opencode/schema/filesystem";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Cause, Context, Effect, Layer, PubSub, RcMap, Schema, Stream } from "effect";
+import { watch } from "node:fs";
+import path from "path";
+var SUBSCRIBE_TIMEOUT_MS = 1e4;
+var Event9 = { Updated: FileSystem.Event.Changed };
+var watcher = lazy2(() => {
+  try {
+    return createWrapper(load2());
+  } catch {
+    return;
+  }
+});
+function getBackend() {
+  if (process.platform === "win32")
+    return "windows";
+  if (process.platform === "darwin")
+    return "fs-events";
+  if (process.platform === "linux")
+    return "inotify";
+}
+var hasNativeBinding2 = () => !!watcher();
+
+class Native3 extends Context.Service()("@opencode/Watcher/Native") {
+}
+var Options8 = Schema.Struct({
+  enabled: Schema.optional(Schema.Boolean)
+});
+
+class Service55 extends Context.Service()("@opencode/Watcher") {
+}
+
+class Test3 extends Context.Service()("@opencode/Watcher/Test") {
+}
+var layer19 = (options) => Layer.effect(Service55, Effect.gen(function* () {
+  if (options?.enabled === false) {
+    return Service55.of({ subscribe: () => Effect.succeed(Stream.empty) });
+  }
+  const native = yield* Native3;
+  const watchers = yield* RcMap.make({
+    lookup: (key) => Effect.gen(function* () {
+      const pubsub = yield* Effect.acquireRelease(PubSub.unbounded(), (pubsub) => PubSub.shutdown(pubsub));
+      const subscription = yield* Effect.acquireRelease(native.subscribe({
+        ...key,
+        publish: (update) => PubSub.publishUnsafe(pubsub, update)
+      }), (subscription) => subscription ? Effect.promise(() => subscription.unsubscribe()).pipe(Effect.ignoreCause, Effect.andThen(Effect.logInfo("watcher stopped", { path: key.target, type: key.type }))) : Effect.void, { interruptible: true });
+      if (!subscription) {
+        yield* PubSub.shutdown(pubsub);
+        return pubsub;
+      }
+      yield* Effect.logInfo("watcher started", {
+        path: key.target,
+        type: key.type,
+        backend: subscription.backend,
+        ignores: key.ignore.length
+      });
+      return pubsub;
+    })
+  });
+  const subscribe = Effect.fnUntraced(function* (input, onReady = Effect.void) {
+    const target = path.resolve(input.path);
+    const ignore = [...new Set(input.type === "directory" ? input.ignore ?? [] : [])].toSorted();
+    const names = [...new Set(input.type === "entries" ? input.names : [])].toSorted();
+    yield* Effect.logInfo("watcher subscribe", {
+      path: target,
+      type: input.type,
+      ignores: ignore.length
+    });
+    return Stream.unwrap(Effect.gen(function* () {
+      const pubsub = yield* RcMap.get(watchers, { type: input.type, target, ignore, names });
+      const subscription = yield* PubSub.subscribe(pubsub);
+      if (yield* PubSub.isShutdown(pubsub))
+        return Stream.empty;
+      yield* onReady;
+      return Stream.fromSubscription(subscription);
+    }));
+  });
+  return Service55.of({ subscribe });
+}));
+var testLayer3 = Layer.effectContext(Effect.gen(function* () {
+  const subscriptions = [];
+  const active = new Map;
+  const native = Native3.of({
+    subscribe: (input) => Effect.sync(() => {
+      subscriptions.push(input.type === "file" ? { path: input.target, type: "file" } : input.type === "entries" ? { path: input.target, type: "entries", names: input.names } : input.ignore.length > 0 ? { path: input.target, type: "directory", ignore: input.ignore } : { path: input.target, type: "directory" });
+      const ignored = input.ignore.map((entry) => path.resolve(input.target, entry));
+      active.set(input.publish, (target) => {
+        if (input.type === "file")
+          return target === input.target;
+        if (input.type === "entries")
+          return path.dirname(target) === input.target && input.names.includes(path.basename(target));
+        return FSUtil.contains(input.target, target) && !ignored.some((entry) => FSUtil.contains(entry, target));
+      });
+      return {
+        unsubscribe: () => {
+          active.delete(input.publish);
+          return Promise.resolve();
+        }
+      };
+    })
+  });
+  const context = yield* Layer.build(layer19().pipe(Layer.provide(Layer.succeed(Native3, native))));
+  const test = Test3.of({
+    subscribe: Context.get(context, Service55).subscribe,
+    emit: (update) => Effect.sync(() => {
+      const target = path.resolve(update.path);
+      active.forEach((matches, publish) => {
+        if (matches(target))
+          publish(update);
+      });
+    }),
+    subscriptions: () => Effect.sync(() => [...subscriptions])
+  });
+  return Context.empty().pipe(Context.add(Service55, test), Context.add(Test3, test));
+}));
+var nativeLayer2 = Layer.succeed(Native3, Native3.of({
+  subscribe: (input) => {
+    if (input.type === "file" || input.type === "entries") {
+      return Effect.sync(() => {
+        const directory = input.type === "file" ? path.dirname(input.target) : input.target;
+        const names = new Set(input.type === "file" ? [path.basename(input.target)] : input.names);
+        const subscription = watch(directory, { recursive: false }, (_event, file) => {
+          if (file && !names.has(file))
+            return;
+          for (const name of file ? [file] : names) {
+            input.publish({ path: path.join(directory, name), type: "update" });
+          }
+        });
+        subscription.on("error", (error) => Effect.runFork(Effect.logError("watcher callback failed", { path: directory, error })));
+        return { unsubscribe: () => Promise.resolve(subscription.close()), backend: "node" };
+      });
+    }
+    return subscribeDirectory(watcher(), getBackend(), input.target, input.ignore, input.publish);
+  }
+}));
+var nativeNode2 = makeGlobalNode({ service: Native3, layer: nativeLayer2, deps: [] });
+function configured8(options) {
+  return makeGlobalNode({ service: Service55, layer: layer19(options), deps: [nativeNode2] });
+}
+var node59 = configured8();
+function subscribeDirectory(native, backend, directory, ignore, publish) {
+  if (!native || !backend) {
+    return Effect.logError("watcher backend not supported", { directory, platform: process.platform }).pipe(Effect.as(undefined));
+  }
+  const callback = (error, updates) => {
+    if (error)
+      Effect.runFork(Effect.logError("watcher callback failed", { error }));
+    for (const update of updates)
+      publish(update);
+  };
+  const pending = native.subscribe(directory, callback, { ignore: [...ignore], backend });
+  return Effect.promise(() => pending).pipe(Effect.map((subscription) => ({ unsubscribe: () => subscription.unsubscribe(), backend })), Effect.onInterrupt(() => Effect.sync(() => {
+    pending.then((subscription) => subscription.unsubscribe()).catch(() => {});
+  })), Effect.timeout(SUBSCRIBE_TIMEOUT_MS), Effect.catchCause((cause) => Effect.logError("failed to subscribe", {
+    directory,
+    cause: Cause.pretty(cause)
+  }).pipe(Effect.as(undefined))));
+}
+
+export { Event9, hasNativeBinding2, Native3, Options8, Service55, Test3, layer19, testLayer3, nativeLayer2, nativeNode2, configured8, node59, exports_watcher };

package/dist/chunks/worktree-cf4snx6d.js

@@ -0,0 +1,107 @@
+// src/database/drizzle/sqlite-core/effect/query.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import {
+  makeDefaultRqbMapper
+} from "drizzle-orm/relations";
+import { sql } from "drizzle-orm/sql/sql";
+
+class SQLiteEffectRelationalQueryBuilder2 {
+  schema;
+  table;
+  tableConfig;
+  dialect;
+  session;
+  rowMode;
+  forbidJsonb;
+  static [entityKind] = "SQLiteEffectRelationalQueryBuilderV2";
+  constructor(schema, table, tableConfig, dialect, session, rowMode, forbidJsonb) {
+    this.schema = schema;
+    this.table = table;
+    this.tableConfig = tableConfig;
+    this.dialect = dialect;
+    this.session = session;
+    this.rowMode = rowMode;
+    this.forbidJsonb = forbidJsonb;
+  }
+  findMany(config) {
+    return new SQLiteEffectRelationalQuery2(this.schema, this.table, this.tableConfig, this.dialect, this.session, config ?? true, "many", this.rowMode, this.forbidJsonb);
+  }
+  findFirst(config) {
+    return new SQLiteEffectRelationalQuery2(this.schema, this.table, this.tableConfig, this.dialect, this.session, config ?? true, "first", this.rowMode, this.forbidJsonb);
+  }
+}
+
+class SQLiteEffectRelationalQuery2 {
+  schema;
+  tableConfig;
+  dialect;
+  session;
+  config;
+  rowMode;
+  forbidJsonb;
+  static [entityKind] = "SQLiteEffectRelationalQueryV2";
+  mode;
+  table;
+  constructor(schema, table, tableConfig, dialect, session, config, mode, rowMode, forbidJsonb) {
+    this.schema = schema;
+    this.tableConfig = tableConfig;
+    this.dialect = dialect;
+    this.session = session;
+    this.config = config;
+    this.rowMode = rowMode;
+    this.forbidJsonb = forbidJsonb;
+    this.mode = mode;
+    this.table = table;
+  }
+  getSQL() {
+    return this._getQuery().sql;
+  }
+  _prepare(isOneTimeQuery = true) {
+    const { query, builtQuery } = this._toSQL();
+    const mapperConfig = {
+      isFirst: this.mode === "first",
+      parseJson: !this.rowMode,
+      parseJsonIfString: false,
+      rootJsonMappers: true,
+      selection: query.selection
+    };
+    return this.session[isOneTimeQuery ? "prepareOneTimeRelationalQuery" : "prepareRelationalQuery"](builtQuery, undefined, this.mode === "first" ? "get" : "all", makeDefaultRqbMapper(mapperConfig), mapperConfig);
+  }
+  prepare() {
+    return this._prepare(false);
+  }
+  _getQuery() {
+    const jsonb = this.forbidJsonb ? sql`json` : sql`jsonb`;
+    const query = this.dialect.buildRelationalQuery({
+      schema: this.schema,
+      table: this.table,
+      tableConfig: this.tableConfig,
+      queryConfig: this.config,
+      mode: this.mode,
+      isNested: this.rowMode,
+      jsonb
+    });
+    if (this.rowMode) {
+      const jsonColumns = sql.join(query.selection.map((s) => {
+        return sql`${sql.raw(this.dialect.escapeString(s.key))}, ${s.selection ? sql`${jsonb}(${sql.identifier(s.key)})` : sql.identifier(s.key)}`;
+      }), sql`, `);
+      query.sql = sql`select json_object(${jsonColumns}) as ${sql.identifier("r")} from (${query.sql}) as ${sql.identifier("t")}`;
+    }
+    return query;
+  }
+  _toSQL() {
+    const query = this._getQuery();
+    const builtQuery = this.dialect.sqlToQuery(query.sql);
+    return { query, builtQuery };
+  }
+  toSQL() {
+    return this._toSQL().builtQuery;
+  }
+  execute(placeholderValues) {
+    return this.mode === "first" ? this._prepare().get(placeholderValues) : this._prepare().all(placeholderValues);
+  }
+}
+applyEffectWrapper(SQLiteEffectRelationalQuery2);
+
+export { SQLiteEffectRelationalQueryBuilder2, SQLiteEffectRelationalQuery2 };

package/dist/chunks/worktree-cnd7bjr1.js

@@ -0,0 +1,157 @@
+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 {
+  InvalidPatternError2,
+  Service45
+} from "./worktree-f8jtvgnz.js";
+import {
+  DEFAULT_SEARCH_LIMIT2,
+  DEFAULT_SEARCH_TIMEOUT_MS2,
+  GrepInput2,
+  Entry2,
+  Match2
+} 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/grep.ts
+var exports_grep = {};
+__export(exports_grep, {
+  GrepTool: () => exports_grep,
+  Input: () => Input8,
+  Output: () => Output6,
+  Plugin: () => Plugin9,
+  name: () => name8,
+  toModelContent: () => toModelContent4
+});
+import { ToolFailure } from "@opencode/ai";
+import { Effect, Schema } from "effect";
+import path from "path";
+var name8 = "grep";
+var Input8 = Schema.Struct({
+  pattern: GrepInput2.fields.pattern.check(Schema.isMinLength(1, { message: "Pattern must not be empty" })).annotate({
+    description: "Regular expression or literal text to match in file contents."
+  }),
+  path: Schema.optionalKey(RelativePath2).annotate({
+    description: "File or directory to search. Defaults to the current working directory."
+  }),
+  include: GrepInput2.fields.include.annotate({
+    description: 'Glob pattern to filter files (for example, "*.js" or "*.{ts,tsx}")'
+  }),
+  literal: GrepInput2.fields.literal.annotate({
+    description: "Treat `pattern` as exact text instead of a regular expression (default: false)."
+  }),
+  caseSensitive: GrepInput2.fields.caseSensitive.annotate({
+    description: "Use case-sensitive matching (default: true)."
+  }),
+  limit: GrepInput2.fields.limit.annotate({
+    description: `Maximum number of matching lines to return (default: ${DEFAULT_SEARCH_LIMIT2})`
+  })
+});
+var Output6 = Schema.Array(Match2);
+var toModelContent4 = (matches, truncated = false) => {
+  const lines = matches.length === 0 ? ["No matches found"] : [`Found ${matches.length} matches`];
+  let current = "";
+  for (const match of matches) {
+    if (current !== match.entry.path) {
+      if (current)
+        lines.push("");
+      current = match.entry.path;
+      lines.push(`${match.entry.path}:`);
+    }
+    lines.push(`  Line ${match.line}: ${match.text}`);
+  }
+  if (truncated)
+    lines.push("", `(Results are truncated: showing first ${matches.length} results. Consider using a more specific path or pattern.)`);
+  return lines.join(`
+`);
+};
+var Plugin9 = {
+  id: "opencode.tool.grep",
+  effect: Effect.fn("GrepTool.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: name8,
+      options: { codemode: false },
+      description: "Search file contents using ripgrep's regular expression syntax or literal text matching. Use it to locate specific code, symbols, or text patterns, and narrow searches with `path` or `include`. Returns matching file paths, line numbers, and line previews.",
+      input: Input8,
+      output: Output6,
+      execute: (input, context) => Effect.gen(function* () {
+        const source = { type: "tool", messageID: context.messageID, id: context.id };
+        const target = yield* access.resolve({ path: input.path ?? "." });
+        yield* access.authorizeExternal([target], context);
+        yield* permission.assert({
+          action: name8,
+          resources: [input.pattern],
+          save: ["*"],
+          metadata: {
+            root: ".",
+            path: input.path,
+            include: input.include,
+            literal: input.literal,
+            caseSensitive: input.caseSensitive,
+            limit: input.limit
+          },
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source
+        });
+        const root = target.absolute;
+        const type = yield* typeFollowing2(environment.files, root).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `Search path does not exist: ${input.path ?? "."}` }))));
+        const cwd = type === "directory" ? root : path.dirname(root);
+        const limit = input.limit ?? DEFAULT_SEARCH_LIMIT2;
+        const matches = yield* ripgrep.grep({
+          cwd,
+          pattern: input.pattern,
+          file: type === "file" ? path.basename(root) : undefined,
+          include: input.include,
+          literal: input.literal,
+          caseSensitive: input.caseSensitive,
+          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((match) => Match2.make({
+          ...match,
+          entry: Entry2.make({
+            ...match.entry,
+            path: RelativePath2.make(path.relative(location.directory, path.resolve(cwd, match.entry.path)))
+          })
+        }))));
+        return { matches: matches.slice(0, limit), truncated: matches.length > limit };
+      }).pipe(Effect.map((result) => ({
+        output: result.matches,
+        content: toModelContent4(result.matches.map((match) => ({
+          ...match,
+          entry: { ...match.entry, path: path.resolve(location.directory, match.entry.path) }
+        })), result.truncated),
+        metadata: { matches: result.matches.length, truncated: result.truncated }
+      })), Effect.mapError((error) => error instanceof ToolFailure ? error : error instanceof InvalidPatternError2 ? new ToolFailure({ message: `Invalid regex pattern: ${error.message}` }) : new ToolFailure({ message: `Unable to grep for ${input.pattern}`, error })))
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name8, Input8, Output6, toModelContent4, Plugin9, exports_grep };

package/dist/chunks/worktree-cvy3z8tj.js

@@ -0,0 +1,15 @@
+// src/database/migration/20260622142730_simplify_session_context_epoch.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260622142730_simplify_session_context_epoch",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session_context_epoch\` DROP COLUMN \`agent\`;`);
+      yield* tx.run(`ALTER TABLE \`session_context_epoch\` DROP COLUMN \`replacement_seq\`;`);
+      yield* tx.run(`ALTER TABLE \`session_context_epoch\` DROP COLUMN \`revision\`;`);
+    });
+  }
+};
+var _20260622142730_simplify_session_context_epoch_default = migration;
+
+export { _20260622142730_simplify_session_context_epoch_default };

package/dist/chunks/worktree-cyhn230w.js

@@ -0,0 +1,173 @@
+import {
+  ID11,
+  Family2
+} from "./worktree-esam66tc.js";
+import {
+  Service54
+} from "./worktree-r82b328h.js";
+import {
+  foldSettings2
+} from "./worktree-asseqh46.js";
+
+// src/plugin/provider/ollama.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Duration, Effect, Schedule, Schema, Semaphore, Stream } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+var providerID = "ollama";
+var Details = Schema.Struct({
+  parent_model: Schema.String.pipe(Schema.optional),
+  format: Schema.String,
+  family: Schema.String,
+  families: Schema.Array(Schema.String).pipe(Schema.optional),
+  parameter_size: Schema.String,
+  quantization_level: Schema.String
+});
+var RemoteModel = Schema.Struct({
+  name: Schema.String,
+  model: Schema.String,
+  remote_model: Schema.String.pipe(Schema.optional),
+  remote_host: Schema.String.pipe(Schema.optional),
+  modified_at: Schema.String,
+  size: Schema.Int,
+  digest: Schema.String,
+  details: Details
+});
+var TagsResponse = Schema.Struct({ models: Schema.Array(RemoteModel) });
+var ShowRequest = Schema.Struct({ model: Schema.String });
+var ShowResponse = Schema.Struct({
+  parameters: Schema.String.pipe(Schema.optional),
+  license: Schema.String.pipe(Schema.optional),
+  modified_at: Schema.String.pipe(Schema.optional),
+  details: Details.pipe(Schema.optional),
+  template: Schema.String.pipe(Schema.optional),
+  capabilities: Schema.Array(Schema.String).pipe(Schema.optional),
+  model_info: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional)
+});
+var discovery = new Map;
+var discoveryLock = Semaphore.makeUnsafe(1);
+function make9(origin = "http://127.0.0.1:11434", interval = "30 seconds") {
+  return define({
+    id: "opencode.provider.ollama",
+    effect: Effect.fn(function* (ctx) {
+      const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+      const config = yield* Service54;
+      const source = { current: configured(yield* config.entries(), origin) };
+      const loaded = { models: [], hash: "[]" };
+      yield* ctx.integration.transform((integrations) => {
+        if (loaded.models.length === 0)
+          return;
+        integrations.remove(providerID);
+      });
+      yield* ctx.catalog.transform((catalog) => {
+        if (loaded.models.length === 0)
+          return;
+        for (const model of catalog.provider.get(providerID)?.models.values() ?? []) {
+          catalog.model.remove(providerID, model.id);
+        }
+        catalog.provider.update(providerID, (provider) => {
+          provider.name = "Ollama";
+          provider.activation = "enabled";
+          provider.package = "@opencode/ai/providers/openai-compatible";
+          provider.settings = {
+            baseURL: source.current.baseURL,
+            provider: providerID,
+            apiKey: source.current.apiKey ?? ""
+          };
+          provider.integrationID = undefined;
+        });
+        for (const item of loaded.models) {
+          catalog.model.update(providerID, item.model, (model) => {
+            model.modelID = ID11.make(item.model);
+            model.name = item.name || item.model;
+            model.family = item.show.details?.family ? Family2.make(item.show.details.family) : item.details.family ? Family2.make(item.details.family) : undefined;
+            model.capabilities = {
+              tools: item.show.capabilities?.includes("tools") ?? false,
+              input: ["text", ...item.show.capabilities?.includes("vision") ? ["image"] : []],
+              output: ["text"]
+            };
+            const context = Object.entries(item.show.model_info ?? {}).flatMap(([key, value]) => key.endsWith(".context_length") && typeof value === "number" && value > 0 ? [value] : [])[0];
+            if (context !== undefined)
+              model.limit.context = context;
+          });
+        }
+      });
+      const discover = Effect.fn("OllamaPlugin.discover")(function* () {
+        const current = source.current;
+        if (!current.tagsEndpoint || !current.showEndpoint)
+          return;
+        return yield* discoveryLock.withPermit(Effect.gen(function* () {
+          const cached = discovery.get(current.tagsEndpoint);
+          if (cached && cached.apiKey === current.apiKey && Date.now() - cached.checked < Duration.toMillis(interval))
+            return { source: current, models: cached.models };
+          const previous = cached && cached.apiKey === current.apiKey ? cached : { checked: 0, apiKey: current.apiKey, shows: new Map };
+          discovery.set(current.tagsEndpoint, { ...previous, checked: Date.now(), apiKey: current.apiKey });
+          const tagsRequest = current.apiKey ? HttpClientRequest.get(current.tagsEndpoint).pipe(HttpClientRequest.acceptJson, HttpClientRequest.bearerToken(current.apiKey)) : HttpClientRequest.get(current.tagsEndpoint).pipe(HttpClientRequest.acceptJson);
+          const response = yield* http.execute(tagsRequest).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(TagsResponse)), Effect.timeout("1 second"));
+          const summaries = response.models.filter((model) => model.model.length > 0).toSorted((a, b) => a.model.localeCompare(b.model));
+          const shows = new Map;
+          const models = yield* Effect.forEach(summaries, (model) => Effect.gen(function* () {
+            const saved = previous.shows.get(model.model);
+            const info = saved?.digest === model.digest ? saved.info : yield* HttpClientRequest.post(current.showEndpoint).pipe(HttpClientRequest.acceptJson, current.apiKey ? HttpClientRequest.bearerToken(current.apiKey) : (request) => request, HttpClientRequest.schemaBodyJson(ShowRequest)({ model: model.model }), Effect.flatMap(http.execute), Effect.flatMap(HttpClientResponse.schemaBodyJson(ShowResponse)), Effect.timeout("1 second"));
+            shows.set(model.model, { digest: model.digest, info });
+            return { ...model, show: info };
+          }).pipe(Effect.orElseSucceed(() => {
+            return;
+          })), { concurrency: 4 });
+          const filtered = models.filter((model) => model !== undefined && (model.show.capabilities?.includes("completion") ?? false));
+          discovery.set(current.tagsEndpoint, {
+            checked: Date.now(),
+            apiKey: current.apiKey,
+            models: filtered,
+            shows
+          });
+          return { source: current, models: filtered };
+        }));
+      });
+      const refresh = Effect.fn("OllamaPlugin.refresh")(function* () {
+        const result = yield* discover();
+        if (!result?.models || result.source !== source.current)
+          return;
+        const hash = JSON.stringify(result.models);
+        if (hash === loaded.hash)
+          return;
+        loaded.models = result.models;
+        loaded.hash = hash;
+        yield* ctx.integration.reload();
+        yield* ctx.catalog.reload();
+      });
+      yield* refresh().pipe(Effect.ignore, Effect.repeat(Schedule.spaced(interval)), Effect.forkScoped);
+      const reload = Effect.fn("OllamaPlugin.reload")(function* () {
+        const next = configured(yield* config.entries(), origin);
+        if (next.baseURL === source.current.baseURL && next.apiKey === source.current.apiKey && next.tagsEndpoint === source.current.tagsEndpoint)
+          return;
+        source.current = next;
+        loaded.models = [];
+        loaded.hash = "[]";
+        yield* ctx.integration.reload();
+        yield* ctx.catalog.reload();
+        yield* refresh().pipe(Effect.ignore);
+      });
+      yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(reload), Effect.forkScoped({ startImmediately: true }));
+    })
+  });
+}
+var OllamaPlugin2 = make9();
+function configured(entries, origin) {
+  const settings = foldSettings2(entries, providerID, undefined);
+  const baseURL = (typeof settings?.baseURL === "string" ? settings.baseURL : `${origin.replace(/\/+$/, "")}/v1`).replace(/\/+$/, "");
+  const apiKey = typeof settings?.apiKey === "string" ? settings.apiKey : undefined;
+  if (!URL.canParse(baseURL))
+    return { baseURL, apiKey };
+  const url = new URL(baseURL);
+  if (url.protocol !== "http:" && url.protocol !== "https:")
+    return { baseURL, apiKey };
+  const prefix = url.pathname.endsWith("/v1") ? url.pathname.slice(0, -3) : url.pathname.replace(/\/+$/, "");
+  url.pathname = `${prefix}/api/tags`;
+  url.search = "";
+  url.hash = "";
+  const tagsEndpoint = url.toString();
+  url.pathname = `${prefix}/api/show`;
+  return { baseURL, apiKey, tagsEndpoint, showEndpoint: url.toString() };
+}
+
+export { make9, OllamaPlugin2 };