@opencode-ai/core 0.0.0-beta-19086 → 0.0.0-beta-19124

package/dist/chunks/{schema-1jjzsk9c.js → event-logger-4yxs9dbd.js}

@@ -1,54 +1,54 @@
 import {
-  collectBoundedResponseBody
-} from "./schema-jve7t217.js";
+  Service71
+} from "./event-logger-yzjhj2th.js";
 import {
-  MAX_MARKDOWN_BYTES,
-  convertHTMLToMarkdown
-} from "./schema-bybkghrn.js";
+  MAX_MARKDOWN_BYTES2,
+  convertHTMLToMarkdown2
+} from "./event-logger-a1tpkmh4.js";
 import {
-  exports_permission
-} from "./schema-1nf5m1zv.js";
+  collectBoundedResponseBody2
+} from "./event-logger-3v8g72cx.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/tool/plugin/webfetch.ts
 var exports_webfetch = {};
 __export(exports_webfetch, {
-  DEFAULT_TIMEOUT_SECONDS: () => DEFAULT_TIMEOUT_SECONDS,
-  Input: () => Input,
-  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES,
-  MAX_TIMEOUT_SECONDS: () => MAX_TIMEOUT_SECONDS,
-  Plugin: () => Plugin,
+  DEFAULT_TIMEOUT_SECONDS: () => DEFAULT_TIMEOUT_SECONDS2,
+  Input: () => Input4,
+  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES3,
+  MAX_TIMEOUT_SECONDS: () => MAX_TIMEOUT_SECONDS2,
+  Plugin: () => Plugin17,
   WebFetchTool: () => exports_webfetch,
-  convertHTMLToMarkdown: () => convertHTMLToMarkdown,
-  description: () => description,
-  extractTextFromHTML: () => extractTextFromHTML,
-  name: () => name
+  convertHTMLToMarkdown: () => convertHTMLToMarkdown2,
+  description: () => description3,
+  extractTextFromHTML: () => extractTextFromHTML2,
+  name: () => name4
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Duration, Effect, Schema } from "effect";
 import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
 import { Parser } from "htmlparser2";
-var name = "webfetch";
-var MAX_RESPONSE_BYTES = MAX_MARKDOWN_BYTES;
-var DEFAULT_TIMEOUT_SECONDS = 30;
-var MAX_TIMEOUT_SECONDS = 120;
-var description = `Fetch content from an HTTP or HTTPS URL and return it as text, markdown, or HTML. Markdown is the default.
+var name4 = "webfetch";
+var MAX_RESPONSE_BYTES3 = MAX_MARKDOWN_BYTES2;
+var DEFAULT_TIMEOUT_SECONDS2 = 30;
+var MAX_TIMEOUT_SECONDS2 = 120;
+var description3 = `Fetch content from an HTTP or HTTPS URL and return it as text, markdown, or HTML. Markdown is the default.
 
 Use a more targeted tool when one is available. This tool is read-only. Large text results may be replaced with a preview while the complete output is retained in managed storage.`;
-var Timeout = Schema.Finite.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(MAX_TIMEOUT_SECONDS));
-var Input = Schema.Struct({
+var Timeout = Schema.Finite.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(MAX_TIMEOUT_SECONDS2));
+var Input4 = Schema.Struct({
   url: Schema.String.annotate({ description: "The HTTP or HTTPS URL to fetch content from" }),
   format: Schema.Literals(["text", "markdown", "html"]).annotate({ description: "The format to return the content in. Defaults to markdown." }).pipe(Schema.withDecodingDefaultKey(Effect.succeed("markdown"))),
   timeout: Schema.optionalKey(Timeout).annotate({
-    description: `Optional timeout in seconds (maximum: ${MAX_TIMEOUT_SECONDS})`
+    description: `Optional timeout in seconds (maximum: ${MAX_TIMEOUT_SECONDS2})`
   })
 });
 var Output = Schema.Struct({
   url: Schema.String,
   contentType: Schema.String,
-  format: Input.fields.format,
+  format: Input4.fields.format,
   output: Schema.String
 });
 var acceptHeader = (format) => {
@@ -79,7 +79,7 @@ var assertHttpUrl = (url) => {
     throw new Error("URL must use http:// or https://");
 };
 var execute = (http, url, format, userAgent = openCodeUserAgent) => http.execute(request(url, format, userAgent)).pipe(Effect.flatMap(HttpClientResponse.filterStatusOk));
-var collectBody = (response) => collectBoundedResponseBody(response, MAX_RESPONSE_BYTES, () => new Error(`Response too large (exceeds ${MAX_RESPONSE_BYTES} byte limit)`));
+var collectBody = (response) => collectBoundedResponseBody2(response, MAX_RESPONSE_BYTES3, () => new Error(`Response too large (exceeds ${MAX_RESPONSE_BYTES3} byte limit)`));
 var mimeFrom = (contentType) => contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
 var isImageAttachment = (mime) => mime.startsWith("image/") && mime !== "image/svg+xml" && mime !== "image/vnd.fastbidsheet";
 var isTextualMime = (mime) => !mime || mime.startsWith("text/") || mime === "application/json" || mime.endsWith("+json") || mime === "application/xml" || mime.endsWith("+xml") || mime === "application/javascript" || mime === "application/x-javascript";
@@ -87,21 +87,21 @@ var convert = (content, contentType, format) => {
   if (!contentType.includes("text/html"))
     return content;
   if (format === "markdown")
-    return convertHTMLToMarkdown(content);
+    return convertHTMLToMarkdown2(content);
   if (format === "text")
-    return extractTextFromHTML(content);
+    return extractTextFromHTML2(content);
   return content;
 };
-var Plugin = {
+var Plugin17 = {
   id: "opencode.tool.webfetch",
   effect: Effect.fn("WebFetchTool.Plugin")(function* (ctx) {
     const http = yield* HttpClient.HttpClient;
-    const permission = yield* exports_permission.Service;
+    const permission = yield* Service71;
     yield* ctx.tool.transform((editor) => editor.add({
-      name,
+      name: name4,
       options: { codemode: false },
-      description,
-      input: Input,
+      description: description3,
+      input: Input4,
       output: Output,
       execute: (input, context) => Effect.gen(function* () {
         yield* Effect.try({
@@ -109,7 +109,7 @@ var Plugin = {
           catch: (error) => error
         });
         yield* permission.assert({
-          action: name,
+          action: name4,
           resources: [input.url],
           save: ["*"],
           metadata: input,
@@ -119,15 +119,15 @@ var Plugin = {
         });
         const { body, contentType } = yield* Effect.gen(function* () {
           const response = yield* execute(http, input.url, input.format).pipe(Effect.catchIf(isCloudflareChallenge, () => execute(http, input.url, input.format, "opencode")));
-          const contentType2 = response.headers["content-type"] || "";
-          const mime = mimeFrom(contentType2);
+          const contentType = response.headers["content-type"] || "";
+          const mime = mimeFrom(contentType);
           if (isImageAttachment(mime))
             return yield* Effect.fail(new Error(`Unsupported fetched image content type: ${mime}`));
           if (!isTextualMime(mime))
             return yield* Effect.fail(new Error(`Unsupported fetched file content type: ${mime}`));
-          return { body: yield* collectBody(response), contentType: contentType2 };
+          return { body: yield* collectBody(response), contentType };
         }).pipe(Effect.timeoutOrElse({
-          duration: Duration.seconds(input.timeout ?? DEFAULT_TIMEOUT_SECONDS),
+          duration: Duration.seconds(input.timeout ?? DEFAULT_TIMEOUT_SECONDS2),
           orElse: () => Effect.fail(new Error("Request timed out"))
         }));
         const content = new TextDecoder().decode(body);
@@ -146,12 +146,12 @@ var Plugin = {
     })).pipe(Effect.orDie);
   })
 };
-function extractTextFromHTML(html) {
+function extractTextFromHTML2(html) {
   let text = "";
   let skipDepth = 0;
   const parser = new Parser({
-    onopentag(name2) {
-      if (skipDepth > 0 || ["script", "style", "noscript", "iframe", "object", "embed"].includes(name2))
+    onopentag(name) {
+      if (skipDepth > 0 || ["script", "style", "noscript", "iframe", "object", "embed"].includes(name))
         skipDepth++;
     },
     ontext(input) {
@@ -167,4 +167,4 @@ function extractTextFromHTML(html) {
   parser.end();
   return text.trim();
 }
-export { name, MAX_RESPONSE_BYTES, DEFAULT_TIMEOUT_SECONDS, MAX_TIMEOUT_SECONDS, description, Input, Plugin, extractTextFromHTML, exports_webfetch };
+export { name4, MAX_RESPONSE_BYTES3, DEFAULT_TIMEOUT_SECONDS2, MAX_TIMEOUT_SECONDS2, description3, Input4, Plugin17, extractTextFromHTML2, exports_webfetch };

package/dist/chunks/{schema-82xa3tgg.js → event-logger-50whrf1e.js}

@@ -1,30 +1,30 @@
 import {
-  exports_permission
-} from "./schema-1nf5m1zv.js";
+  Service70
+} from "./event-logger-xy8v4fm7.js";
 import {
-  exports_form
-} from "./schema-6bwmg5am.js";
+  Service71
+} from "./event-logger-yzjhj2th.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/tool/plugin/question.ts
 var exports_question = {};
 __export(exports_question, {
-  CancelledError: () => CancelledError,
-  Input: () => Input,
-  Output: () => Output,
-  Plugin: () => Plugin,
+  CancelledError: () => CancelledError2,
+  Input: () => Input13,
+  Output: () => Output9,
+  Plugin: () => Plugin45,
   QuestionTool: () => exports_question,
-  description: () => description,
-  name: () => name,
-  toModelContent: () => toModelContent
+  description: () => description6,
+  name: () => name14,
+  toModelContent: () => toModelContent7
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Effect, Schema } from "effect";
 import { Question } from "@opencode-ai/schema/question";
-var name = "question";
-var description = `Use this tool when you need to ask the user questions during execution. This allows you to:
+var name14 = "question";
+var description6 = `Use this tool when you need to ask the user questions during execution. This allows you to:
 1. Gather user preferences or requirements
 2. Clarify ambiguous instructions
 3. Get decisions on implementation choices as you work
@@ -34,33 +34,33 @@ Usage notes:
 - A "Type your own answer" option is added automatically; don't include a separate option for free form answers
 - Set \`multiple: true\` to allow selecting more than one option
 - If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label`;
-var Input = Schema.Struct({
+var Input13 = Schema.Struct({
   questions: Schema.Array(Question.Prompt).check(Schema.isNonEmpty()).annotate({ description: "Questions to ask" })
 });
-var Output = Schema.Struct({
+var Output9 = Schema.Struct({
   answers: Schema.Array(Question.Answer)
 });
 
-class CancelledError extends Schema.TaggedError()("QuestionTool.CancelledError", {}) {
+class CancelledError2 extends Schema.TaggedError()("QuestionTool.CancelledError", {}) {
   get message() {
     return "The user dismissed this question";
   }
 }
-var toModelContent = (questions, answers) => {
+var toModelContent7 = (questions, answers) => {
   const formatted = questions.map((question, index) => `"${question.question}"="${answers[index]?.length ? answers[index].join(", ") : "Unanswered"}"`).join(", ");
   return `User has answered your questions: ${formatted}. You can now continue with the user's answers in mind.`;
 };
-var Plugin = {
+var Plugin45 = {
   id: "opencode.tool.question",
   effect: Effect.fn("QuestionTool.Plugin")(function* (ctx) {
-    const forms = yield* exports_form.Service;
-    const permission = yield* exports_permission.Service;
+    const forms = yield* Service70;
+    const permission = yield* Service71;
     yield* ctx.tool.transform((editor) => editor.add({
-      name,
+      name: name14,
       options: { codemode: false },
-      description,
-      input: Input,
-      output: Output,
+      description: description6,
+      input: Input13,
+      output: Output9,
       execute: (input, context) => permission.assert({
         action: "question",
         resources: ["*"],
@@ -80,7 +80,7 @@ var Plugin = {
         ]
       }).pipe(Effect.orDie)), Effect.flatMap((state) => {
         if (state.status === "cancelled")
-          return Effect.die(new CancelledError);
+          return Effect.die(new CancelledError2);
         const output = {
           answers: input.questions.map((_, index) => {
             const value = state.answer[`q${index}`];
@@ -93,7 +93,7 @@ var Plugin = {
         };
         return Effect.succeed({
           output,
-          content: toModelContent(input.questions, output.answers),
+          content: toModelContent7(input.questions, output.answers),
           metadata: { answers: output.answers }
         });
       }))
@@ -115,4 +115,4 @@ function toField(question, index) {
   };
 }
 
-export { name, description, Input, Output, CancelledError, toModelContent, Plugin, exports_question };
+export { name14, description6, Input13, Output9, CancelledError2, toModelContent7, Plugin45, exports_question };

package/dist/chunks/{schema-r8f4w671.js → event-logger-550bvhaj.js}

@@ -1,7 +1,7 @@
 // src/github-copilot/responses/openai-error.ts
 import { z } from "zod/v4";
 import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
-var openaiErrorDataSchema = z.object({
+var openaiErrorDataSchema2 = z.object({
   error: z.object({
     message: z.string(),
     type: z.string().nullish(),
@@ -9,9 +9,9 @@ var openaiErrorDataSchema = z.object({
     code: z.union([z.string(), z.number()]).nullish()
   })
 });
-var openaiFailedResponseHandler = createJsonErrorResponseHandler({
-  errorSchema: openaiErrorDataSchema,
+var openaiFailedResponseHandler2 = createJsonErrorResponseHandler({
+  errorSchema: openaiErrorDataSchema2,
   errorToMessage: (data) => data.error.message
 });
 
-export { openaiErrorDataSchema, openaiFailedResponseHandler };
+export { openaiErrorDataSchema2, openaiFailedResponseHandler2 };

package/dist/chunks/{schema-h0f1t520.js → event-logger-57m8p4qp.js}

@@ -1,31 +1,31 @@
 import {
-  exports_mcp
-} from "./schema-kwh3ary7.js";
+  Service48
+} from "./event-logger-47b3sbnz.js";
 import {
-  exports_config
-} from "./schema-jq0ga1pd.js";
+  Service40
+} from "./event-logger-2mqy9ydc.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/config/plugin/mcp.ts
 var exports_mcp2 = {};
 __export(exports_mcp2, {
   ConfigMcpPlugin: () => exports_mcp2,
-  Plugin: () => Plugin,
-  register: () => register
+  Plugin: () => Plugin41,
+  register: () => register2
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect, Stream } from "effect";
-var Plugin = define({
+var Plugin41 = define({
   id: "opencode.config.mcp",
   effect: Effect.fn(function* (ctx) {
-    yield* register(ctx.event.subscribe());
+    yield* register2(ctx.event.subscribe());
   })
 });
-var register = Effect.fn("ConfigMCPPlugin.register")(function* (events) {
-  const config = yield* exports_config.Service;
-  const mcp = yield* exports_mcp.Service;
+var register2 = Effect.fn("ConfigMCPPlugin.register")(function* (events) {
+  const config = yield* Service48;
+  const mcp = yield* Service40;
   const loaded = { entries: [] };
   yield* events.pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(mcp.reload()), Effect.catchCause((cause) => Effect.logError("failed to reload MCP config", { cause })))), Effect.ignore, Effect.forkScoped({ startImmediately: true }));
   loaded.entries = yield* config.entries();
@@ -46,4 +46,4 @@ var register = Effect.fn("ConfigMCPPlugin.register")(function* (events) {
   });
 });
 
-export { Plugin, register, exports_mcp2 as exports_mcp };
+export { Plugin41, register2, exports_mcp2 };

package/dist/chunks/{schema-fxa7vmmn.js → event-logger-5c1zb16k.js}

@@ -1,27 +1,31 @@
 import {
-  exports_source_directory
-} from "./schema-51t2tyks.js";
+  Service49,
+  node52
+} from "./event-logger-jfbh8m2n.js";
 import {
-  exports_config
-} from "./schema-jq0ga1pd.js";
+  Service75,
+  node80
+} from "./event-logger-00s3pqt3.js";
 import {
-  exports_watcher
-} from "./schema-v9qxqszp.js";
+  Service48,
+  node51
+} from "./event-logger-47b3sbnz.js";
 import {
-  exports_location
-} from "./schema-9kt3hna5.js";
+  names2,
+  discover2
+} from "./event-logger-zxq2ej10.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/config/plugin/source.ts
 var exports_source = {};
 __export(exports_source, {
   ConfigPluginSource: () => exports_source,
-  Service: () => Service,
-  empty: () => empty,
-  layer: () => layer,
-  node: () => node
+  Service: () => Service11,
+  empty: () => empty2,
+  layer: () => layer7,
+  node: () => node14
 });
 import { FSUtil } from "@opencode-ai/util/fs-util";
 import { Host } from "@opencode-ai/plugin/host";
@@ -29,13 +33,13 @@ import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Option, PubSub, Stream } from "effect";
 import path from "path";
 import { fileURLToPath, pathToFileURL } from "url";
-class Service extends Context.Service()("@opencode/ConfigPluginSource") {
+class Service11 extends Context.Service()("@opencode/ConfigPluginSource") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const config = yield* exports_config.Service;
-  const watcher = yield* exports_watcher.Service;
+var layer7 = Layer.effect(Service11, Effect.gen(function* () {
+  const config = yield* Service48;
+  const watcher = yield* Service49;
   const fs = yield* FSUtil.Service;
-  const location = yield* exports_location.Service;
+  const location = yield* Service75;
   const configuredChanges = yield* PubSub.unbounded();
   const watched = new Set;
   const watchConfiguredSources = Effect.fn("ConfigPluginSource.watchConfiguredSources")(function* (entries, operations) {
@@ -54,7 +58,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       yield* updates.pipe(Stream.runForEach(() => PubSub.publish(configuredChanges, undefined)), Effect.catchCause((cause) => Effect.logError("configured plugin watch failed", { target: operation.target, cause })), Effect.forkScoped({ startImmediately: true }));
     }
   });
-  return Service.of({
+  return Service11.of({
     operations: Effect.fn("ConfigPluginSource.operations")(function* () {
       const entries = yield* config.entries();
       const operations = yield* scan(fs, location, entries);
@@ -66,14 +70,14 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     })), Stream.fromPubSub(configuredChanges))
   });
 }));
-var node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [exports_config.node, FSUtil.node, exports_watcher.node, exports_location.node]
+var node14 = makeLocationNode({
+  service: Service11,
+  layer: layer7,
+  deps: [node51, FSUtil.node, node52, node80]
 });
-var empty = makeLocationNode({
-  service: Service,
-  layer: Layer.succeed(Service, Service.of({
+var empty2 = makeLocationNode({
+  service: Service11,
+  layer: Layer.succeed(Service11, Service11.of({
     operations: () => Effect.succeed([]),
     changes: () => Stream.never
   })),
@@ -90,7 +94,7 @@ function parse(input) {
   return { type: "remove", target: input.slice(1) };
 }
 var scan = Effect.fn("ConfigPluginSource.scan")(function* (fs, location, entries) {
-  const discovered = yield* Effect.forEach(entries.filter((entry) => entry.type === "directory"), (entry) => exports_source_directory.discover(fs, entry.path).pipe(Effect.map((targets) => targets.map((target) => ({ type: "add", target, options: {} }))))).pipe(Effect.map((items) => items.flat()));
+  const discovered = yield* Effect.forEach(entries.filter((entry) => entry.type === "directory"), (entry) => discover2(fs, entry.path).pipe(Effect.map((targets) => targets.map((target) => ({ type: "add", target, options: {} }))))).pipe(Effect.map((items) => items.flat()));
   const configured = entries.filter((entry) => entry.type === "document").flatMap((entry) => (entry.info.plugins ?? []).map(parse).map((operation) => {
     if (operation.type === "remove")
       return operation;
@@ -130,7 +134,7 @@ var scan = Effect.fn("ConfigPluginSource.scan")(function* (fs, location, entries
   })).pipe(Effect.map((operations) => operations.flat()));
 });
 function isPluginSource(entries, file) {
-  return entries.some((entry) => entry.type === "directory" && exports_source_directory.names.some((directory) => FSUtil.contains(path.join(entry.path, directory), file)));
+  return entries.some((entry) => entry.type === "directory" && names2.some((directory) => FSUtil.contains(path.join(entry.path, directory), file)));
 }
 
-export { Service, layer, node, empty, exports_source };
+export { Service11, layer7, node14, empty2, exports_source };

package/dist/chunks/event-logger-5c3qnfth.js

@@ -0,0 +1,24 @@
+import {
+  mergeOverlay2
+} from "./event-logger-rwbhhn1p.js";
+import {
+  Service67
+} from "./event-logger-hdqmeh3c.js";
+import {
+  Service48
+} from "./event-logger-47b3sbnz.js";
+
+// src/plugin/provider/configured.ts
+import { Effect, Option } from "effect";
+var configuredSettings2 = Effect.fn("ProviderPlugin.configuredSettings")(function* (id) {
+  const catalog = yield* Service67;
+  const current = (yield* catalog.provider.get(id))?.settings;
+  const service = yield* Effect.serviceOption(Service48);
+  const entries = Option.isSome(service) ? yield* service.value.entries() : [];
+  return foldSettings2(entries, id, current);
+});
+function foldSettings2(entries, id, initial) {
+  return entries.filter((entry) => entry.type === "document").reduce((settings, entry) => mergeOverlay2(settings, entry.info.providers?.[id]?.settings), initial);
+}
+
+export { configuredSettings2, foldSettings2 };

package/dist/chunks/{schema-p5gyct0y.js → event-logger-5daktx2q.js}

@@ -1,31 +1,31 @@
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/config/markdown.ts
 var exports_markdown = {};
 __export(exports_markdown, {
   ConfigMarkdown: () => exports_markdown,
-  parse: () => parse,
-  parseOption: () => parseOption,
-  sanitize: () => sanitize
+  parse: () => parse3,
+  parseOption: () => parseOption2,
+  sanitize: () => sanitize2
 });
 import matter from "gray-matter";
-function parse(content) {
+function parse3(content) {
   try {
     return matter(content);
   } catch {
-    return matter(sanitize(content));
+    return matter(sanitize2(content));
   }
 }
-function parseOption(content) {
+function parseOption2(content) {
   try {
-    return parse(content);
+    return parse3(content);
   } catch {
     return;
   }
 }
-function sanitize(content) {
+function sanitize2(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!match)
     return content;
@@ -47,4 +47,4 @@ function sanitize(content) {
 `));
 }
 
-export { parse, parseOption, sanitize, exports_markdown };
+export { parse3, parseOption2, sanitize2, exports_markdown };

package/dist/chunks/{schema-f2nhxfjt.js → event-logger-5fmxt4p5.js}

@@ -1,12 +1,9 @@
 import {
-  createProviderPlugin
-} from "./schema-0zz82cjq.js";
-import {
-  __require
-} from "./schema-vpjkya7h.js";
+  createProviderPlugin2
+} from "./event-logger-se0s1eqw.js";
 
 // src/plugin/provider/cohere.ts
-var CoherePlugin = createProviderPlugin({
+var CoherePlugin2 = createProviderPlugin2({
   id: "opencode.provider.cohere",
   package: "@ai-sdk/cohere",
   load: async (options) => {
@@ -15,4 +12,4 @@ var CoherePlugin = createProviderPlugin({
   }
 });
 
-export { CoherePlugin };
+export { CoherePlugin2 };

package/dist/chunks/{schema-xp4wtg3g.js → event-logger-5fww7ark.js}

@@ -1,12 +1,12 @@
 import {
-  foldSettings
-} from "./schema-f3dqxhwr.js";
+  ID10
+} from "./event-logger-ar3vq2rb.js";
 import {
-  exports_config
-} from "./schema-jq0ga1pd.js";
+  Service48
+} from "./event-logger-47b3sbnz.js";
 import {
-  exports_model
-} from "./schema-8manx9kj.js";
+  foldSettings2
+} from "./event-logger-5c3qnfth.js";
 
 // src/plugin/provider/vllm.ts
 import { define } from "@opencode-ai/plugin/effect/plugin";
@@ -21,12 +21,12 @@ var RemoteModel = Schema.Struct({
 var Response = Schema.Struct({ data: Schema.Array(RemoteModel) });
 var discovery = new Map;
 var discoveryLock = Semaphore.makeUnsafe(1);
-function make(origin = "http://127.0.0.1:8000", interval = "30 seconds") {
+function make6(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* exports_config.Service;
+      const config = yield* Service48;
       const source = { current: configured(yield* config.entries(), origin) };
       const loaded = { models: [], hash: "[]" };
       yield* ctx.integration.transform((integrations) => {
@@ -53,7 +53,7 @@ function make(origin = "http://127.0.0.1:8000", interval = "30 seconds") {
         });
         for (const item of loaded.models) {
           catalog.model.update(providerID, item.id, (model) => {
-            model.modelID = exports_model.ID.make(item.id);
+            model.modelID = ID10.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)
@@ -76,7 +76,7 @@ ${current.modelsEndpoint}`;
             apiKey: current.apiKey,
             models: cached && cached.apiKey === current.apiKey ? cached.models : undefined
           });
-          const request = (endpoint2) => current.apiKey ? HttpClientRequest.get(endpoint2).pipe(HttpClientRequest.acceptJson, HttpClientRequest.bearerToken(current.apiKey)) : HttpClientRequest.get(endpoint2).pipe(HttpClientRequest.acceptJson);
+          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));
@@ -112,9 +112,9 @@ ${current.modelsEndpoint}`;
     })
   });
 }
-var VLLMPlugin = make();
+var VLLMPlugin2 = make6();
 function configured(entries, origin) {
-  const settings = foldSettings(entries, providerID, undefined);
+  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))
@@ -134,4 +134,4 @@ function configured(entries, origin) {
   return { baseURL, apiKey, healthEndpoint: health.toString(), modelsEndpoint: models.toString() };
 }
 
-export { make, VLLMPlugin };
+export { make6, VLLMPlugin2 };