@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-h6t842eb.js

@@ -0,0 +1,326 @@
+import {
+  NotFound2,
+  WrongKind2,
+  Failed2
+} from "./aisdk-native-2a5m3afh.js";
+import {
+  Service73
+} from "./aisdk-native-6fyvx278.js";
+import {
+  Service71
+} from "./aisdk-native-ms882c9x.js";
+import {
+  Service18
+} from "./aisdk-native-4b9mceyk.js";
+import {
+  Service16,
+  readText2,
+  syncTextBom2
+} from "./aisdk-native-aqpgmyrr.js";
+import {
+  Service59
+} from "./aisdk-native-h05a6ep0.js";
+import {
+  Service17,
+  resolvePath2
+} from "./aisdk-native-svw2bsx3.js";
+import {
+  fileDiff2
+} from "./aisdk-native-6prwharc.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/tool/plugin/patch.ts
+var exports_patch = {};
+__export(exports_patch, {
+  Applied: () => Applied2,
+  Input: () => Input5,
+  Output: () => Output4,
+  PatchTool: () => exports_patch,
+  Plugin: () => Plugin37,
+  name: () => name5,
+  toModelContent: () => toModelContent3
+});
+import { ToolFailure } from "@opencode/ai";
+import { FileDiff } from "@opencode/schema/file-diff";
+import { Effect, Result, Schema } from "effect";
+import { Bom } from "@opencode/util/bom";
+import { Patch } from "@opencode/util/patch";
+
+// src/tool/patch.txt
+var patch_default = `Use the \`patch\` tool to edit files. Your patch language is a stripped‑down, file‑oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high‑level envelope:
+
+*** Begin Patch
+[ one or more file sections ]
+*** End Patch
+
+Within that envelope, you get a sequence of file operations.
+You MUST include a header to specify the action you are taking.
+Each operation starts with one of three headers:
+
+*** Add File: <path> - create a new file. Every following line is a + line (the initial contents).
+*** Delete File: <path> - remove an existing file. Nothing follows.
+*** Update File: <path> - patch an existing file in place (optionally with a rename).
+
+Example patch:
+
+\`\`\`
+*** Begin Patch
+*** Add File: hello.txt
++Hello world
+*** Update File: src/app.py
+*** Move to: src/main.py
+@@ def greet():
+-print("Hi")
++print("Hello, world!")
+*** Delete File: obsolete.txt
+*** End Patch
+\`\`\`
+
+It is important to remember:
+
+- You must include a header with your intended action (Add/Delete/Update)
+- You must prefix new lines with \`+\` even when creating a new file
+`;
+
+// src/tool/plugin/patch.ts
+var name5 = "patch";
+var Input5 = Schema.Struct({
+  patchText: Schema.String.annotate({
+    description: "The full patch text describing add, update, and delete operations"
+  })
+});
+var Applied2 = Schema.Struct({
+  type: Schema.Literals(["add", "update", "delete"]),
+  resource: Schema.String,
+  target: Schema.String
+});
+var Output4 = Schema.Struct({
+  applied: Schema.Array(Applied2),
+  files: Schema.Array(FileDiff.Info)
+});
+var toModelContent3 = (output) => [
+  "Success. Updated the following files:",
+  ...output.applied.map((item) => `${item.type === "add" ? "A" : item.type === "delete" ? "D" : "M"} ${item.resource}`)
+].join(`
+`);
+var Plugin37 = {
+  id: "opencode.tool.patch",
+  effect: Effect.fn("PatchTool.Plugin")(function* (ctx) {
+    const environment = yield* Service71;
+    const access = yield* Service17;
+    const fileMutation = yield* Service16;
+    const formatter = yield* Service18;
+    const location = yield* Service73;
+    const permission = yield* Service59;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name5,
+      options: { codemode: false, permission: "edit" },
+      description: patch_default,
+      input: Input5,
+      output: Output4,
+      execute: (input, context) => {
+        const applied = [];
+        const parsed = Patch.parse(input.patchText);
+        const lockTargets = Result.isSuccess(parsed) ? parsed.success.flatMap((hunk) => [
+          resolvePath2(location.directory, hunk.path),
+          ...hunk.type === "update" && hunk.movePath ? [resolvePath2(location.directory, hunk.movePath)] : []
+        ]) : [];
+        const fail = (operation, error) => {
+          const completed = applied.map((item) => item.resource).join(", ");
+          return new ToolFailure({
+            message: `${operation}: ${errorMessage(error)}${completed ? `. Completed before failure: ${completed}` : ""}`
+          });
+        };
+        return Effect.gen(function* () {
+          const source = {
+            type: "tool",
+            messageID: context.messageID,
+            id: context.id
+          };
+          if (!input.patchText)
+            return yield* new ToolFailure({ message: "patchText is required" });
+          const hunks = yield* Effect.fromResult(parsed).pipe(Effect.mapError((error) => new ToolFailure({ message: `patch verification failed: ${error.message}` })));
+          if (hunks.length === 0) {
+            return yield* new ToolFailure({ message: "patch rejected: empty patch" });
+          }
+          const prepared = [];
+          const updates = new Map;
+          const resolveTarget = Effect.fnUntraced(function* (value) {
+            const target = yield* access.resolve({ path: value, kind: "file" });
+            if (!target.externalDirectory)
+              return target;
+            yield* access.authorizeExternal([target], context, {
+              filepath: target.absolute,
+              parentDir: target.externalDirectory.directory
+            });
+            return target;
+          });
+          for (const hunk of hunks) {
+            yield* Effect.gen(function* () {
+              const target = yield* resolveTarget(hunk.path);
+              if (hunk.type === "add") {
+                const content = hunk.contents.endsWith(`
+`) || hunk.contents === "" ? hunk.contents : `${hunk.contents}
+`;
+                prepared.push({
+                  ...hunk,
+                  target,
+                  content,
+                  before: "",
+                  after: Bom.split(content).text
+                });
+                return;
+              }
+              if (hunk.type === "delete") {
+                const content = yield* readText2(environment.files, target.absolute).pipe(Effect.mapError((error) => new ToolFailure({
+                  message: `patch verification failed: Failed to delete ${target.resource}: ${errorMessage(error)}`
+                })));
+                prepared.push({ ...hunk, target, before: content.text, after: "" });
+                return;
+              }
+              const previous = updates.get(target.absolute);
+              const original = previous ?? (yield* Effect.gen(function* () {
+                const content = yield* readText2(environment.files, target.absolute).pipe(Effect.mapError((error) => new ToolFailure({
+                  message: `patch verification failed: Failed to read file to update ${target.absolute}: ${errorMessage(error)}`
+                })));
+                return Bom.join(content.text, content.bom);
+              }));
+              const before = Bom.split(original).text;
+              const update = yield* Effect.try({
+                try: () => Patch.derive(hunk.path, hunk.chunks, original),
+                catch: (error) => new ToolFailure({ message: `patch verification failed: ${errorMessage(error)}` })
+              });
+              const moveTarget = hunk.movePath ? yield* resolveTarget(hunk.movePath) : undefined;
+              prepared.push({
+                ...hunk,
+                target,
+                content: Patch.joinBom(update.content, update.bom),
+                before,
+                after: update.content,
+                moveTarget
+              });
+              if (!moveTarget)
+                updates.set(target.absolute, Patch.joinBom(update.content, update.bom));
+            }).pipe(Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to prepare patch at ${hunk.path}`, error })));
+          }
+          const patchFiles = prepared.map((change) => patchFile(change));
+          const targets = prepared.flatMap((change) => [
+            change.target,
+            ...change.type === "update" && change.moveTarget ? [change.moveTarget] : []
+          ]);
+          yield* permission.assert({
+            action: "edit",
+            resources: [...new Set(targets.map((target) => target.resource))],
+            save: ["*"],
+            metadata: {
+              filepath: targets.map((target) => target.resource).join(", "),
+              diff: patchFiles.map((file) => `${file.patch}
+`).join(""),
+              files: patchFiles
+            },
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source
+          });
+          yield* Effect.forEach(prepared, (change) => Effect.gen(function* () {
+            if (change.type === "delete") {
+              yield* environment.files.remove(change.target.absolute).pipe(Effect.mapError((error) => fail(`Failed to delete ${change.target.resource}`, error)));
+              applied.push({
+                type: change.type,
+                resource: change.target.resource,
+                target: change.target.absolute
+              });
+              return;
+            }
+            if (change.type === "update" && change.moveTarget) {
+              const moveTarget = change.moveTarget;
+              yield* environment.files.write(moveTarget.absolute, new TextEncoder().encode(change.content)).pipe(Effect.mapError((error) => fail(`Failed to write ${moveTarget.resource}`, error)));
+              yield* environment.files.remove(change.target.absolute).pipe(Effect.mapError((error) => fail(`Wrote ${moveTarget.resource} but failed to remove ${change.target.resource}`, error)));
+              applied.push({
+                type: change.type,
+                resource: change.moveTarget.resource,
+                target: change.moveTarget.absolute
+              });
+              return;
+            }
+            yield* environment.files.write(change.target.absolute, new TextEncoder().encode(change.content)).pipe(Effect.mapError((error) => fail(`Failed to write ${change.target.resource}`, error)));
+            applied.push({
+              type: change.type,
+              resource: change.target.resource,
+              target: change.target.absolute
+            });
+          }), { discard: true });
+          const formatted = new Map;
+          yield* Effect.forEach([...new Set(applied.filter((item) => item.type !== "delete").map((item) => item.target))], (target) => Effect.gen(function* () {
+            const current = yield* readText2(environment.files, target).pipe(Effect.mapError((error) => fail(`Failed to read ${target}`, error)));
+            formatted.set(target, (yield* formatter.file(target)) ? yield* syncTextBom2(environment.files, target, current.bom).pipe(Effect.mapError((error) => fail(`Failed to sync ${target}`, error))) : current.text);
+          }), { discard: true });
+          const files = prepared.map((change) => {
+            if (change.type === "delete")
+              return patchFile(change);
+            const target = change.type === "update" && change.moveTarget ? change.moveTarget : change.target;
+            return patchFile(change, formatted.get(target.absolute));
+          });
+          return { applied, files };
+        }).pipe(fileMutation.withLock(lockTargets), Effect.map((output) => ({
+          output,
+          content: toModelContent3(output),
+          metadata: { files: output.files }
+        })), Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: "Unable to apply patch", error })));
+      }
+    })).pipe(Effect.orDie);
+    yield* ctx.session.hook("context", (event) => Effect.sync(() => {
+      const usePatch = event.model.id.includes("gpt-") && !event.model.id.includes("oss") && !event.model.id.includes("gpt-4");
+      if (usePatch) {
+        delete event.tools.edit;
+        delete event.tools.write;
+        return;
+      }
+      delete event.tools.patch;
+    }));
+  })
+};
+function errorMessage(error) {
+  if (error instanceof NotFound2)
+    return "file does not exist";
+  if (error instanceof WrongKind2)
+    return error.actual === "directory" ? "path is a directory" : `path is ${error.actual}`;
+  if (error instanceof Failed2)
+    return errorMessage(error.cause);
+  return error instanceof Error ? error.message : String(error);
+}
+function patchFile(change, after = change.after) {
+  const target = (change.type === "update" ? change.moveTarget : undefined)?.resource ?? change.target.resource;
+  const diff = fileDiff2(change.target.absolute, change.before, after, change.type === "add" ? "added" : change.type === "delete" ? "deleted" : "modified");
+  return {
+    ...diff,
+    file: target,
+    patch: trimDiff(diff.patch)
+  };
+}
+function trimDiff(diff) {
+  const lines = diff.split(`
+`);
+  const content = lines.filter((line) => (line.startsWith("+") || line.startsWith("-") || line.startsWith(" ")) && !line.startsWith("---") && !line.startsWith("+++"));
+  if (content.length === 0)
+    return diff;
+  const indent = content.reduce((result, line) => {
+    const value = line.slice(1);
+    if (value.trim().length === 0)
+      return result;
+    return Math.min(result, value.match(/^(\s*)/)?.[1].length ?? result);
+  }, Infinity);
+  if (indent === Infinity || indent === 0)
+    return diff;
+  return lines.map((line) => {
+    if ((line.startsWith("+") || line.startsWith("-") || line.startsWith(" ")) && !line.startsWith("---") && !line.startsWith("+++")) {
+      return line[0] + line.slice(1 + indent);
+    }
+    return line;
+  }).join(`
+`);
+}
+
+export { name5, Input5, Applied2, Output4, toModelContent3, Plugin37, exports_patch };

package/dist/chunks/aisdk-native-h6vf3j39.js

@@ -0,0 +1,14 @@
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/util/token.ts
+var exports_token = {};
+__export(exports_token, {
+  Token: () => exports_token,
+  estimate: () => estimate2
+});
+var CHARS_PER_TOKEN = 4;
+var estimate2 = (input) => Math.max(0, Math.round(input.length / CHARS_PER_TOKEN));
+
+export { estimate2, exports_token };

package/dist/chunks/aisdk-native-h7ch2b13.js

@@ -0,0 +1,38 @@
+import {
+  Service35
+} from "./aisdk-native-y9tfvs3x.js";
+import {
+  match2
+} from "./aisdk-native-y1fvbwt7.js";
+import {
+  observe2
+} from "./aisdk-native-qsdy395h.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/config/plugin/policy.ts
+var exports_policy = {};
+__export(exports_policy, {
+  ConfigPolicyPlugin: () => exports_policy,
+  Plugin: () => Plugin6
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+var Plugin6 = define({
+  id: "opencode.config.policy",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service35;
+    const loaded = yield* observe2(config, ctx.event, ctx.catalog.reload());
+    yield* ctx.catalog.transform((catalog) => {
+      const policies = loaded.entries.filter((entry) => entry.type === "document").toReversed().flatMap((entry) => entry.info.experimental?.policies ?? []);
+      for (const record of catalog.provider.list()) {
+        const policy = policies.findLast((policy) => match2(record.provider.id, policy.resource));
+        if (policy?.effect === "deny")
+          catalog.provider.remove(record.provider.id);
+      }
+    });
+  })
+});
+
+export { Plugin6, exports_policy };

package/dist/chunks/aisdk-native-hamfyrt4.js

@@ -0,0 +1,82 @@
+import {
+  Service59
+} from "./aisdk-native-h05a6ep0.js";
+import {
+  ID4,
+  Name2,
+  toModelOutput3,
+  prepare3,
+  Service50
+} from "./aisdk-native-rd6pz67j.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/tool/plugin/skill.ts
+var exports_skill3 = {};
+__export(exports_skill3, {
+  Input: () => Input3,
+  Output: () => Output2,
+  Plugin: () => Plugin34,
+  SkillTool: () => exports_skill3,
+  description: () => description2,
+  name: () => name3,
+  toModelOutput: () => toModelOutput2
+});
+import { ToolFailure } from "@opencode/ai";
+import { Effect, Schema } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+var name3 = "skill";
+var Input3 = Schema.Struct({
+  id: ID4.annotate({ description: "The ID of an available skill or a skill explicitly referenced by the user" })
+});
+var Output2 = Schema.Struct({
+  name: Name2,
+  directory: Schema.String,
+  output: Schema.String
+});
+var description2 = [
+  "Load a specialized skill's instructions and resources into the current conversation when the task at hand matches its description.",
+  "",
+  "The skill ID must match an available skill or a skill explicitly referenced by the user."
+].join(`
+`);
+var toModelOutput2 = toModelOutput3;
+var unableToLoad = (name, error) => new ToolFailure({ message: `Unable to load skill ${name}`, error });
+var Plugin34 = {
+  id: "opencode.tool.skill",
+  effect: Effect.fn("SkillTool.Plugin")(function* (ctx) {
+    const fs = yield* FSUtil.Service;
+    const skills = yield* Service50;
+    const permission = yield* Service59;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name3,
+      options: { codemode: false },
+      description: description2,
+      input: Input3,
+      output: Output2,
+      execute: (input, context) => Effect.gen(function* () {
+        const skill = yield* skills.get(input.id);
+        if (!skill)
+          return yield* unableToLoad(input.id);
+        return yield* Effect.gen(function* () {
+          yield* permission.assert({
+            action: name3,
+            resources: [skill.id],
+            save: [skill.id],
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source: { type: "tool", messageID: context.messageID, id: context.id }
+          });
+          return { name: skill.name, ...yield* prepare3(fs, skill) };
+        }).pipe(Effect.mapError((error) => unableToLoad(input.id, error)));
+      }).pipe(Effect.map((output) => ({
+        output,
+        content: output.output,
+        metadata: { name: output.name, directory: output.directory }
+      })))
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name3, Input3, Output2, description2, toModelOutput2, Plugin34, exports_skill3 };

package/dist/chunks/aisdk-native-hf4q8sgp.js

@@ -0,0 +1,74 @@
+import {
+  llmClient2
+} from "./aisdk-native-5t3nmthw.js";
+import {
+  Service64,
+  node68
+} from "./aisdk-native-gd0e60kd.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/generate.ts
+var exports_generate2 = {};
+__export(exports_generate2, {
+  Generate: () => exports_generate2,
+  ModelSelectionError: () => ModelSelectionError2,
+  Service: () => Service37,
+  UnavailableError: () => UnavailableError2,
+  layer: () => layer16,
+  node: () => node41
+});
+import { LLM, LLMClient } from "@opencode/ai";
+import { Context, Effect, Layer, Schema } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+class ModelSelectionError2 extends Schema.TaggedError()("Generate.ModelSelectionError", {
+  message: Schema.String
+}) {
+}
+
+class UnavailableError2 extends Schema.TaggedError()("Generate.UnavailableError", {
+  message: Schema.String,
+  service: Schema.optional(Schema.String)
+}) {
+}
+
+class Service37 extends Context.Service()("@opencode/Generate") {
+}
+var layer16 = Layer.effect(Service37, Effect.gen(function* () {
+  const llm = yield* LLMClient.Service;
+  const resolver = yield* Service64;
+  const runText = Effect.fn("Generate.text")(function* (input) {
+    const resolved = yield* resolver.resolve(input.model).pipe(Effect.catchTag([
+      "SessionRunnerModel.VariantUnavailableError",
+      "SessionRunnerModel.UnsupportedPackageError",
+      "SessionRunnerModel.ModelConfigurationError",
+      "SessionRunnerModel.ModelInitializationError",
+      "SessionRunnerModel.UnresolvedProviderVariablesError",
+      "SessionRunnerModel.UnsupportedCompactionError"
+    ], (error) => {
+      const mapped = input.model ? new ModelSelectionError2({ message: error.message }) : new UnavailableError2({ message: error.message, service: error.providerID });
+      return Effect.fail(mapped);
+    }));
+    if (!resolved)
+      return yield* new ModelSelectionError2({
+        message: input.model ? `Model unavailable: ${input.model.providerID}/${input.model.id}` : "No model specified and no supported model is available"
+      });
+    const response = yield* llm.generate(LLM.request({ model: resolved.model, prompt: input.prompt })).pipe(Effect.mapError((error) => new UnavailableError2({
+      message: error.message,
+      service: resolved.ref.providerID
+    })));
+    return response.text;
+  });
+  const text = (input) => runText(input).pipe(Effect.catchTag("Integration.Authorization", () => new UnavailableError2({
+    message: "Generation credentials are unavailable"
+  })));
+  return Service37.of({ text });
+}));
+var node41 = makeLocationNode({
+  service: Service37,
+  layer: layer16,
+  deps: [node68, llmClient2]
+});
+
+export { ModelSelectionError2, UnavailableError2, Service37, layer16, node41, exports_generate2 };

package/dist/chunks/aisdk-native-hj31wtn3.js

@@ -0,0 +1,137 @@
+import {
+  ID13
+} from "./aisdk-native-jghsd1wz.js";
+import {
+  Service35
+} from "./aisdk-native-y9tfvs3x.js";
+import {
+  foldSettings2
+} from "./aisdk-native-6g46d628.js";
+
+// src/plugin/provider/vllm.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 = "vllm";
+var RemoteModel = Schema.Struct({
+  id: Schema.String,
+  owned_by: Schema.String,
+  max_model_len: Schema.NullOr(Schema.Int)
+});
+var Response = Schema.Struct({ data: Schema.Array(RemoteModel) });
+var discovery = new Map;
+var discoveryLock = Semaphore.makeUnsafe(1);
+function make7(origin = "http://127.0.0.1:8000", interval = "30 seconds") {
+  return define({
+    id: "opencode.provider.vllm",
+    effect: Effect.fn(function* (ctx) {
+      const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+      const config = yield* Service35;
+      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 = "vLLM";
+          provider.package = "@opencode/ai/providers/openai-compatible";
+          provider.settings = {
+            baseURL: source.current.baseURL,
+            provider: providerID,
+            apiKey: source.current.apiKey ?? ""
+          };
+          provider.integrationID = undefined;
+          provider.activation = "enabled";
+        });
+        for (const item of loaded.models) {
+          catalog.model.update(providerID, item.id, (model) => {
+            model.modelID = ID13.make(item.id);
+            model.name = item.id;
+            model.capabilities = { tools: false, input: ["text"], output: ["text"] };
+            if (typeof item.max_model_len === "number" && item.max_model_len > 0)
+              model.limit.context = item.max_model_len;
+          });
+        }
+      });
+      const discover = Effect.fn("VLLMPlugin.discover")(function* () {
+        const current = source.current;
+        if (!current.healthEndpoint || !current.modelsEndpoint)
+          return;
+        return yield* discoveryLock.withPermit(Effect.gen(function* () {
+          const endpoint = `${current.healthEndpoint}
+${current.modelsEndpoint}`;
+          const cached = discovery.get(endpoint);
+          if (cached && cached.apiKey === current.apiKey && Date.now() - cached.checked < Duration.toMillis(interval))
+            return { source: current, models: cached.models };
+          discovery.set(endpoint, {
+            checked: Date.now(),
+            apiKey: current.apiKey,
+            models: cached && cached.apiKey === current.apiKey ? cached.models : undefined
+          });
+          const request = (endpoint) => current.apiKey ? HttpClientRequest.get(endpoint).pipe(HttpClientRequest.acceptJson, HttpClientRequest.bearerToken(current.apiKey)) : HttpClientRequest.get(endpoint).pipe(HttpClientRequest.acceptJson);
+          yield* http.execute(request(current.healthEndpoint)).pipe(Effect.timeout("1 second"));
+          const response = yield* http.execute(request(current.modelsEndpoint)).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Response)), Effect.timeout("1 second"));
+          const models = response.data.filter((model) => model.owned_by === providerID && model.id.length > 0).toSorted((a, b) => a.id.localeCompare(b.id));
+          discovery.set(endpoint, { checked: Date.now(), apiKey: current.apiKey, models });
+          return { source: current, models };
+        }));
+      });
+      const refresh = Effect.fn("VLLMPlugin.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("VLLMPlugin.reload")(function* () {
+        const next = configured(yield* config.entries(), origin);
+        if (next.baseURL === source.current.baseURL && next.apiKey === source.current.apiKey && next.healthEndpoint === source.current.healthEndpoint && next.modelsEndpoint === source.current.modelsEndpoint)
+          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 VLLMPlugin2 = make7();
+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 models = new URL(baseURL);
+  if (models.protocol !== "http:" && models.protocol !== "https:")
+    return { baseURL, apiKey };
+  models.pathname = `${models.pathname.replace(/\/+$/, "")}/models`;
+  models.search = "";
+  models.hash = "";
+  const health = new URL(baseURL);
+  const path = health.pathname.replace(/\/+$/, "");
+  const prefix = path.endsWith("/v1") ? path.slice(0, -3) : path;
+  health.pathname = `${prefix}/health`;
+  health.search = "";
+  health.hash = "";
+  return { baseURL, apiKey, healthEndpoint: health.toString(), modelsEndpoint: models.toString() };
+}
+
+export { make7, VLLMPlugin2 };

package/dist/chunks/aisdk-native-hjbc5kem.js

@@ -0,0 +1,13 @@
+// src/plugin/provider/sdk-factory.ts
+import { Effect } from "effect";
+import { importModule, resolveModule } from "@opencode/util/runtime-import";
+var loadSDKFactory2 = Effect.fnUntraced(function* (npm, packageName) {
+  const installedPath = packageName.startsWith("file://") ? packageName : yield* npm.add(packageName).pipe(Effect.orDie, Effect.map((installed) => resolveModule(installed.name, installed.directory)));
+  const mod = yield* Effect.promise(() => importModule(installedPath));
+  const match = Object.keys(mod).find((name) => name.startsWith("create"));
+  if (!match)
+    return yield* Effect.die(new Error(`Package ${packageName} has no provider factory export`));
+  return mod[match];
+});
+
+export { loadSDKFactory2 };