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

package/dist/chunks/{schema-aep5wxg9.js → pty-hkzxevja.js}

@@ -1,34 +1,34 @@
 import {
-  DiffError
-} from "./schema-d26zqcqt.js";
+  Service72
+} from "./pty-5aq0nxp3.js";
 import {
-  MAX_PATCH_BYTES,
-  MAX_TOTAL_PATCH_BYTES,
-  PATCH_CONTEXT_LINES,
-  chunksByFile,
-  emptyPatch
-} from "./schema-3chx3ng6.js";
+  PATCH_CONTEXT_LINES2,
+  MAX_PATCH_BYTES2,
+  MAX_TOTAL_PATCH_BYTES2,
+  emptyPatch2,
+  chunksByFile2
+} from "./pty-tazgh4e4.js";
 import {
-  exports_location
-} from "./schema-9kt3hna5.js";
+  DiffError2
+} from "./pty-wafa9yr2.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/plugin/vcs/git.ts
 var exports_git = {};
 __export(exports_git, {
-  Plugin: () => Plugin,
+  Plugin: () => Plugin16,
   VcsGitPlugin: () => exports_git
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect } from "effect";
 import { ChildProcess } from "effect/unstable/process";
 import { AppProcess } from "@opencode-ai/util/process";
-var Plugin = define({
+var Plugin16 = define({
   id: "opencode.vcs.git",
   effect: Effect.fn("VcsGitPlugin")(function* (ctx) {
-    const location = yield* exports_location.Service;
+    const location = yield* Service72;
     if (location.vcs?.type !== "git")
       return;
     const processes = yield* AppProcess.Service;
@@ -88,7 +88,7 @@ function make(proc, input) {
       const base = options?.base ?? (yield* git.defaultBranch(ctx.directory))?.ref;
       const ref = base ? yield* git.mergeBase(ctx.directory, base) : undefined;
       if (!ref) {
-        return yield* new DiffError({
+        return yield* new DiffError2({
           message: base ? `No merge base available for ${base}` : "No review base available"
         });
       }
@@ -221,7 +221,7 @@ function makeGit(proc) {
       return null;
     const current = yield* branch(cwd);
     if (!current)
-      return yield* new DiffError({ message: "Choose a review base" });
+      return yield* new DiffError2({ message: "Choose a review base" });
     const history = (yield* lines(["reflog", "show", "--max-count=256", "--format=%H%x00%gs", `refs/heads/${current}`], {
       cwd
     })).flatMap((line) => {
@@ -232,25 +232,25 @@ function makeGit(proc) {
     const creation = renamed ? undefined : history.find((entry) => entry.message.startsWith("branch: Created from "));
     const origin = creation?.message.slice("branch: Created from ".length);
     if (creation && origin) {
-      const candidate2 = yield* namedRef(cwd, origin);
-      if (candidate2 && candidate2.name !== current && (yield* ancestor(cwd, creation.commit, "HEAD")) && (yield* ancestor(cwd, creation.commit, candidate2.ref))) {
-        return { ...candidate2, source: "reflog" };
+      const candidate = yield* namedRef(cwd, origin);
+      if (candidate && candidate.name !== current && (yield* ancestor(cwd, creation.commit, "HEAD")) && (yield* ancestor(cwd, creation.commit, candidate.ref))) {
+        return { ...candidate, source: "reflog" };
       }
     }
     const root = yield* defaultBranch(cwd);
     if (!root || current !== root.name)
-      return yield* new DiffError({ message: "Choose a review base" });
+      return yield* new DiffError2({ message: "Choose a review base" });
     const candidate = yield* namedRef(cwd, root.ref);
     if (!candidate)
-      return yield* new DiffError({ message: "The default review base is unavailable" });
+      return yield* new DiffError2({ message: "The default review base is unavailable" });
     return { name: root.name, ref: candidate.ref, source: "default" };
   });
   const hasHead = Effect.fn("VcsGit.hasHead")(function* (cwd) {
     const result = yield* run(["rev-parse", "--verify", "HEAD"], { cwd });
     return result.exitCode === 0;
   });
-  const mergeBase = Effect.fn("VcsGit.mergeBase")(function* (cwd, base2) {
-    const ref = yield* resolve(cwd, base2);
+  const mergeBase = Effect.fn("VcsGit.mergeBase")(function* (cwd, base) {
+    const ref = yield* resolve(cwd, base);
     if (!ref)
       return;
     const result = yield* run(["merge-base", ref, "HEAD"], { cwd });
@@ -270,7 +270,7 @@ function makeGit(proc) {
   const diff = Effect.fn("VcsGit.diffNames")(function* (cwd, ref, target) {
     const result = yield* run(["diff", "--no-ext-diff", "--no-renames", "--name-status", "-z", ref, ...target ? [target] : [], "--", "."], { cwd });
     if (result.exitCode !== 0)
-      return yield* new DiffError({ message: "Unable to list Git changes" });
+      return yield* new DiffError2({ message: "Unable to list Git changes" });
     const list = nuls(result.text());
     return list.flatMap((code, idx) => {
       if (idx % 2 !== 0)
@@ -394,40 +394,40 @@ var batchPatches = Effect.fnUntraced(function* (ctx, ref, list, options) {
     return emptyBatch();
   const result = yield* ctx.git.patchAll(ctx.directory, ref, {
     target: options?.target,
-    context: options?.context ?? PATCH_CONTEXT_LINES,
-    maxOutputBytes: MAX_TOTAL_PATCH_BYTES
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_TOTAL_PATCH_BYTES2
   });
   return {
-    patches: chunksByFile(result, (index) => list[index]?.file),
+    patches: chunksByFile2(result, (index) => list[index]?.file),
     capped: result.truncated
   };
 });
 var nativePatch = Effect.fnUntraced(function* (ctx, ref, item, options) {
   const result = item.code === "??" || !ref ? yield* ctx.git.patchUntracked(ctx.worktree, item.file, {
-    context: options?.context ?? PATCH_CONTEXT_LINES,
-    maxOutputBytes: MAX_PATCH_BYTES
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_PATCH_BYTES2
   }) : yield* ctx.git.patch(ctx.worktree, ref, item.file, {
     target: options?.target,
-    context: options?.context ?? PATCH_CONTEXT_LINES,
-    maxOutputBytes: MAX_PATCH_BYTES
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_PATCH_BYTES2
   });
   if (!result.truncated && result.text)
     return result.text;
-  return emptyPatch(item.file);
+  return emptyPatch2(item.file);
 });
 var totalPatch = (file, patch, total) => {
-  if (total + Buffer.byteLength(patch) <= MAX_TOTAL_PATCH_BYTES)
+  if (total + Buffer.byteLength(patch) <= MAX_TOTAL_PATCH_BYTES2)
     return { patch, capped: false };
-  return { patch: emptyPatch(file), capped: true };
+  return { patch: emptyPatch2(file), capped: true };
 };
 var patchForItem = Effect.fnUntraced(function* (ctx, ref, item, batch, capped, options) {
   if (capped)
-    return emptyPatch(item.file);
+    return emptyPatch2(item.file);
   const batched = batch.patches.get(item.file);
   if (batched !== undefined)
     return batched;
   if (item.code !== "??" && batch.capped)
-    return emptyPatch(item.file);
+    return emptyPatch2(item.file);
   return yield* nativePatch(ctx, ref, item, options);
 });
 var files = Effect.fnUntraced(function* (ctx, ref, list, map, batch, options) {
@@ -441,7 +441,7 @@ var files = Effect.fnUntraced(function* (ctx, ref, list, map, batch, options) {
     capped = capped || result.capped;
     if (!capped) {
       total += Buffer.byteLength(result.patch);
-      capped = total >= MAX_TOTAL_PATCH_BYTES;
+      capped = total >= MAX_TOTAL_PATCH_BYTES2;
     }
     next.push({
       file: item.file,
@@ -467,4 +467,4 @@ var track = Effect.fnUntraced(function* (ctx, ref, options) {
   return yield* diffAgainstRef(ctx, ref, options);
 });
 
-export { Plugin, exports_git };
+export { Plugin16, exports_git };

package/dist/chunks/{schema-5qrxwkqv.js → pty-hqhp5amc.js}

@@ -1,71 +1,73 @@
 import {
-  exports_kv
-} from "./schema-y2b04s9v.js";
+  Service79,
+  node84
+} from "./pty-y974v3mv.js";
 import {
-  exports_state
-} from "./schema-j6s3yjyb.js";
+  Service76,
+  node81
+} from "./pty-xk0vfajd.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  create3
+} from "./pty-kg06axw8.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/websearch.ts
-var exports_websearch = {};
-__export(exports_websearch, {
-  DisabledError: () => DisabledError,
-  Event: () => Event,
-  ID: () => ID,
-  Input: () => Input,
-  Provider: () => Provider,
-  ProviderKey: () => ProviderKey,
-  ProviderNotFoundError: () => ProviderNotFoundError,
-  ProviderRequiredError: () => ProviderRequiredError,
-  RequestError: () => RequestError,
-  Response: () => Response,
-  Result: () => Result,
-  Selection: () => Selection,
-  Service: () => Service,
-  WebSearch: () => exports_websearch,
-  node: () => node
+var exports_websearch3 = {};
+__export(exports_websearch3, {
+  DisabledError: () => DisabledError2,
+  Event: () => Event6,
+  ID: () => ID3,
+  Input: () => Input13,
+  Provider: () => Provider2,
+  ProviderKey: () => ProviderKey2,
+  ProviderNotFoundError: () => ProviderNotFoundError2,
+  ProviderRequiredError: () => ProviderRequiredError2,
+  RequestError: () => RequestError2,
+  Response: () => Response2,
+  Result: () => Result2,
+  Selection: () => Selection2,
+  Service: () => Service24,
+  WebSearch: () => exports_websearch3,
+  node: () => node28
 });
 import { WebSearch } from "@opencode-ai/schema/websearch";
 import { Context, Effect, Layer, Option, Schema } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
-import { Event } from "@opencode-ai/schema/websearch";
-var ID = WebSearch.ID;
-var Provider = WebSearch.Provider;
-var Input = WebSearch.Input;
-var Result = WebSearch.Result;
-var Response = WebSearch.Response;
-var ProviderKey = "websearch:provider";
-var Selection = Schema.Union([ID, Schema.Literal("random"), Schema.Literal(false)]);
+import { Event as Event6 } from "@opencode-ai/schema/websearch";
+var ID3 = WebSearch.ID;
+var Provider2 = WebSearch.Provider;
+var Input13 = WebSearch.Input;
+var Result2 = WebSearch.Result;
+var Response2 = WebSearch.Response;
+var ProviderKey2 = "websearch:provider";
+var Selection2 = Schema.Union([ID3, Schema.Literal("random"), Schema.Literal(false)]);
 
-class ProviderRequiredError extends Schema.TaggedError()("WebSearch.ProviderRequired", {}) {
+class ProviderRequiredError2 extends Schema.TaggedError()("WebSearch.ProviderRequired", {}) {
 }
 
-class ProviderNotFoundError extends Schema.TaggedError()("WebSearch.ProviderNotFound", {
-  providerID: ID
+class ProviderNotFoundError2 extends Schema.TaggedError()("WebSearch.ProviderNotFound", {
+  providerID: ID3
 }) {
 }
 
-class DisabledError extends Schema.TaggedError()("WebSearch.Disabled", {}) {
+class DisabledError2 extends Schema.TaggedError()("WebSearch.Disabled", {}) {
 }
 
-class RequestError extends Schema.TaggedError()("WebSearch.Request", {
-  providerID: ID,
+class RequestError2 extends Schema.TaggedError()("WebSearch.Request", {
+  providerID: ID3,
   cause: Schema.Defect()
 }) {
 }
 
-class Service extends Context.Service()("@opencode/WebSearch") {
+class Service24 extends Context.Service()("@opencode/WebSearch") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const bus = yield* exports_bus.Service;
-  const kv = yield* exports_kv.Service;
-  const decodeResults = Schema.decodeUnknownEffect(Schema.Array(Result));
-  const state = exports_state.create({
+var layer = Layer.effect(Service24, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const kv = yield* Service76;
+  const decodeResults = Schema.decodeUnknownEffect(Schema.Array(Result2));
+  const state = create3({
     initial: () => ({ providers: new Map }),
     editor: (editor) => ({
       add: (provider) => editor.providers.set(provider.id, provider),
@@ -78,17 +80,17 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   });
   const requireProvider = (providers, providerID) => {
     const provider = providers.get(providerID);
-    return provider ? Effect.succeed(provider) : Effect.fail(new ProviderNotFoundError({ providerID }));
+    return provider ? Effect.succeed(provider) : Effect.fail(new ProviderNotFoundError2({ providerID }));
   };
   const defaultProvider = Effect.fn("WebSearch.default")(function* () {
     const data = state.get();
-    const stored = data.selection === undefined ? yield* kv.get(ProviderKey) : undefined;
-    const decoded = Schema.decodeUnknownOption(Selection)(stored);
+    const stored = data.selection === undefined ? yield* kv.get(ProviderKey2) : undefined;
+    const decoded = Schema.decodeUnknownOption(Selection2)(stored);
     if (stored !== undefined && Option.isNone(decoded))
-      yield* kv.remove(ProviderKey);
+      yield* kv.remove(ProviderKey2);
     const selection = data.selection ?? Option.getOrUndefined(decoded);
     if (selection === false)
-      return yield* new DisabledError;
+      return yield* new DisabledError2;
     if (selection === "random") {
       const providers = Array.from(data.providers.values());
       return providers[Math.floor(Math.random() * providers.length)];
@@ -101,10 +103,10 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       return yield* requireProvider(providers, input.providerID);
     const provider = yield* defaultProvider();
     if (!provider)
-      return yield* new ProviderRequiredError;
+      return yield* new ProviderRequiredError2;
     return provider;
   });
-  return Service.of({
+  return Service24.of({
     transform: state.transform,
     reload: state.reload,
     providers: Effect.fn("WebSearch.providers")(function* () {
@@ -118,19 +120,19 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       return provider && { id: provider.id, name: provider.name };
     }),
     select: Effect.fn("WebSearch.select")(function* (selection) {
-      yield* kv.set(ProviderKey, selection);
+      yield* kv.set(ProviderKey2, selection);
     }),
     query: Effect.fn("WebSearch.query")(function* (input) {
       const provider = yield* resolve(input);
-      const results = yield* provider.execute({ query: input.query }).pipe(Effect.flatMap(decodeResults), Effect.mapError((cause) => new RequestError({ providerID: provider.id, cause })));
-      return new Response({ providerID: provider.id, results });
+      const results = yield* provider.execute({ query: input.query }).pipe(Effect.flatMap(decodeResults), Effect.mapError((cause) => new RequestError2({ providerID: provider.id, cause })));
+      return new Response2({ providerID: provider.id, results });
     })
   });
 }));
-var node = makeLocationNode({
-  service: Service,
+var node28 = makeLocationNode({
+  service: Service24,
   layer,
-  deps: [exports_bus.node, exports_kv.node]
+  deps: [node84, node81]
 });
 
-export { ID, Provider, Input, Result, Response, ProviderKey, Selection, ProviderRequiredError, ProviderNotFoundError, DisabledError, RequestError, Service, node, exports_websearch, Event };
+export { ID3, Provider2, Input13, Result2, Response2, ProviderKey2, Selection2, ProviderRequiredError2, ProviderNotFoundError2, DisabledError2, RequestError2, Service24, node28, exports_websearch3, Event6 };

package/dist/chunks/{schema-wb7ccp3j.js → pty-j2n289q7.js}

@@ -1,29 +1,31 @@
 import {
-  exports_integration
-} from "./schema-b9bp1awf.js";
+  ID5,
+  Service49
+} from "./pty-pk02mbyy.js";
 import {
-  exports_provider
-} from "./schema-68yag814.js";
+  isAISDK2,
+  packageName2
+} from "./pty-tdt6s1r3.js";
 
 // src/plugin/provider/llmgateway.ts
 import { Effect } from "effect";
 import { define } from "@opencode-ai/plugin/effect/plugin";
-var LLMGatewayPlugin = define({
+var LLMGatewayPlugin2 = define({
   id: "opencode.provider.llmgateway",
   effect: Effect.fn(function* (ctx) {
-    const integrations = yield* exports_integration.Service;
+    const integrations = yield* Service49;
     const configured = new Set((yield* integrations.list()).map((integration) => integration.id));
     yield* ctx.catalog.transform((evt) => {
       for (const item of evt.provider.list()) {
         if (item.provider.activation === "disabled")
           continue;
-        if (!exports_provider.isAISDK(item.provider.package))
+        if (!isAISDK2(item.provider.package))
           continue;
-        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/openai-compatible")
+        if (packageName2(item.provider.package) !== "@ai-sdk/openai-compatible")
           continue;
         if (item.provider.settings?.baseURL !== "https://api.llmgateway.io/v1")
           continue;
-        if (!configured.has(exports_integration.ID.make(item.provider.id)))
+        if (!configured.has(ID5.make(item.provider.id)))
           continue;
         evt.provider.update(item.provider.id, (provider) => {
           provider.headers = {
@@ -38,4 +40,4 @@ var LLMGatewayPlugin = define({
   })
 });
 
-export { LLMGatewayPlugin };
+export { LLMGatewayPlugin2 };

package/dist/chunks/pty-j5w0a358.js

@@ -0,0 +1,35 @@
+import {
+  latest2,
+  Service62
+} from "./pty-amgxn0m4.js";
+import {
+  observe2
+} from "./pty-qsdy395h.js";
+import {
+  __export
+} from "./pty-9rqn6x4v.js";
+
+// src/config/plugin/websearch.ts
+var exports_websearch2 = {};
+__export(exports_websearch2, {
+  ConfigWebSearchPlugin: () => exports_websearch2,
+  Plugin: () => Plugin38
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect } from "effect";
+var Plugin38 = define({
+  id: "opencode.config.websearch",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service62;
+    const loaded = yield* observe2(config, ctx.event, ctx.websearch.reload());
+    yield* ctx.websearch.transform((websearch) => {
+      const selection = latest2(loaded.entries, "websearch");
+      if (selection === false)
+        websearch.default.set(false);
+      if (selection)
+        websearch.default.set(selection.provider);
+    });
+  })
+});
+
+export { Plugin38, exports_websearch2 };

package/dist/chunks/{schema-vac9eqd2.js → pty-j5zkgpj8.js}

@@ -7,7 +7,7 @@ function isFileId(data, prefixes) {
     return false;
   return prefixes.some((prefix) => data.startsWith(prefix));
 }
-async function convertToOpenAIResponsesInput({
+async function convertToOpenAIResponsesInput2({
   prompt,
   systemMessageMode,
   fileIdPrefixes,
@@ -223,4 +223,4 @@ var openaiResponsesReasoningProviderOptionsSchema = z.object({
   reasoningEncryptedContent: z.string().nullish()
 });
 
-export { convertToOpenAIResponsesInput };
+export { convertToOpenAIResponsesInput2 };

package/dist/chunks/{schema-eyr78tzb.js → pty-jab386st.js}

@@ -1,25 +1,28 @@
 import {
-  exports_store
-} from "./schema-a4wk7wxx.js";
+  Service79,
+  node84
+} from "./pty-y974v3mv.js";
 import {
-  SessionEvent
-} from "./schema-a83yvq99.js";
+  Service72,
+  node77
+} from "./pty-5aq0nxp3.js";
 import {
-  exports_location
-} from "./schema-9kt3hna5.js";
+  SessionEvent2
+} from "./pty-mntxs535.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  Service54,
+  node58
+} from "./pty-1459b0x6.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/session/instructions.ts
 var exports_instructions = {};
 __export(exports_instructions, {
-  Service: () => Service,
+  Service: () => Service6,
   SessionInstructions: () => exports_instructions,
-  node: () => node
+  node: () => node9
 });
 import { relative } from "path";
 import { Context, Effect, Layer, Option, Ref, Schema } from "effect";
@@ -29,13 +32,13 @@ var InjectedMetadata = Schema.Struct({
   instruction: Schema.Struct({ paths: Schema.Array(Schema.String) })
 });
 
-class Service extends Context.Service()("@opencode/SessionInstructions") {
+class Service6 extends Context.Service()("@opencode/SessionInstructions") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const bus = yield* exports_bus.Service;
+var layer = Layer.effect(Service6, Effect.gen(function* () {
+  const bus = yield* Service79;
   const fs = yield* FSUtil.Service;
-  const store = yield* exports_store.Service;
-  const location = yield* exports_location.Service;
+  const store = yield* Service54;
+  const location = yield* Service72;
   const root = yield* fs.resolve(location.project.directory);
   const inFlight = yield* Ref.make(new Map);
   const load = Effect.fn("SessionInstructions.load")(function* (input) {
@@ -59,7 +62,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       const readable = files.filter((file) => file !== undefined);
       if (readable.length === 0)
         return;
-      yield* bus.publish(SessionEvent.Synthetic, {
+      yield* bus.publish(SessionEvent2.Synthetic, {
         sessionID: input.sessionID,
         text: readable.map((file) => `Instructions from: ${file.path}
 ${file.content}`).join(`
@@ -81,7 +84,7 @@ ${file.content}`).join(`
       return next;
     })));
   });
-  return Service.of({ load });
+  return Service6.of({ load });
 }));
 function previouslyInjected(store, sessionID) {
   return Effect.gen(function* () {
@@ -92,10 +95,10 @@ function previouslyInjected(store, sessionID) {
 function describePath(root, path) {
   return FSUtil.contains(root, path) ? relative(root, path) : path;
 }
-var node = makeLocationNode({
+var node9 = makeLocationNode({
   name: "session-instructions",
   layer,
-  deps: [exports_bus.node, FSUtil.node, exports_location.node, exports_store.node]
+  deps: [node84, FSUtil.node, node77, node58]
 });
 
-export { Service, node, exports_instructions };
+export { Service6, node9, exports_instructions };