@opencode-ai/core 0.0.0-dev-19092 → 0.0.0-dev-19094

package/dist/chunks/{integration-r8f4w671.js → command-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/command-55yvdk0c.js

@@ -0,0 +1,35 @@
+import {
+  __export
+} from "./command-9rqn6x4v.js";
+
+// src/app.ts
+var exports_app = {};
+__export(exports_app, {
+  App: () => exports_app,
+  Metadata: () => Metadata2,
+  configured: () => configured11,
+  layer: () => layer25,
+  make: () => make20,
+  node: () => node81,
+  useragent: () => useragent2
+});
+import { Context, Layer } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+var Metadata2 = Context.Reference("@opencode/App", {
+  defaultValue: () => make20()
+});
+function make20(input = {}) {
+  return {
+    name: input.name ?? "opencode",
+    version: input.version ?? "unknown",
+    channel: input.channel ?? "unknown"
+  };
+}
+function useragent2(app) {
+  return `opencode/${app.channel}/${app.version}/${app.name}`;
+}
+var layer25 = (input) => Layer.succeed(Metadata2, make20(input));
+var configured11 = (input) => makeGlobalNode({ service: Metadata2, layer: layer25(input), deps: [] });
+var node81 = configured11();
+
+export { Metadata2, make20, useragent2, layer25, configured11, node81, exports_app };

package/dist/chunks/command-578j1xdj.js

@@ -0,0 +1,87 @@
+import {
+  SessionMessage2
+} from "./command-982e01ww.js";
+import {
+  SessionSchema2
+} from "./command-5rw6je3s.js";
+import {
+  MessageDecodeError2
+} from "./command-c28brx2k.js";
+import {
+  InitializationBlocked2,
+  read3
+} from "./command-mtcjf44p.js";
+import {
+  SessionMessageTable2
+} from "./command-hrvm11jt.js";
+import {
+  initial2,
+  preview3
+} from "./command-g7csxrs7.js";
+import {
+  __export
+} from "./command-9rqn6x4v.js";
+
+// src/session/history.ts
+var exports_history = {};
+__export(exports_history, {
+  SessionHistory: () => exports_history,
+  decodeMessageRow: () => decodeMessageRow2,
+  entriesForRunner: () => entriesForRunner2,
+  firstUserMessage: () => firstUserMessage2,
+  latestCompaction: () => latestCompaction2,
+  load: () => load3,
+  preview: () => preview2
+});
+import { and, asc, desc, eq, gte, sql } from "drizzle-orm";
+import { Effect, Schema } from "effect";
+var decode = Schema.decodeUnknownEffect(SessionMessage2.Info);
+var latestCompaction2 = Effect.fnUntraced(function* (db, sessionID) {
+  return yield* db.select({ seq: SessionMessageTable2.seq }).from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, sessionID), eq(SessionMessageTable2.type, "compaction"), sql`json_extract(${SessionMessageTable2.data}, '$.status') = 'completed'`)).orderBy(desc(SessionMessageTable2.seq)).limit(1).get().pipe(Effect.orDie);
+});
+var decodeMessageRow2 = (row) => decode({ ...row.data, id: row.id, type: row.type }).pipe(Effect.mapError(() => new MessageDecodeError2({
+  sessionID: SessionSchema2.ID.make(row.session_id),
+  messageID: SessionMessage2.ID.make(row.id)
+})));
+var messageEntries = Effect.fnUntraced(function* (db, sessionID) {
+  const compaction = yield* latestCompaction2(db, sessionID);
+  const rows = yield* db.select().from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, sessionID), compaction ? gte(SessionMessageTable2.seq, compaction.seq) : undefined)).orderBy(asc(SessionMessageTable2.seq)).all().pipe(Effect.orDie);
+  return yield* Effect.forEach(rows, (row) => decodeMessageRow2(row).pipe(Effect.map((message) => ({ seq: row.seq, message }))));
+});
+var load3 = Effect.fn("SessionHistory.load")(function* (db, sessionID) {
+  return (yield* messageEntries(db, sessionID)).map((entry) => entry.message);
+});
+var entriesForRunner2 = Effect.fn("SessionHistory.entriesForRunner")(function* (db, sessionID, instructions) {
+  return yield* db.transaction(() => Effect.gen(function* () {
+    const messages = yield* messageEntries(db, sessionID);
+    return {
+      initial: yield* initial2(db, sessionID, instructions),
+      entries: messages
+    };
+  })).pipe(Effect.orDie);
+});
+var preview2 = Effect.fn("SessionHistory.preview")(function* (db, sessionID, instructions) {
+  const observed = yield* read3(instructions);
+  return yield* db.transaction(() => Effect.gen(function* () {
+    const messages = yield* messageEntries(db, sessionID);
+    const unsettled = messages.findIndex((entry) => entry.message.type === "assistant" && entry.message.time.completed === undefined);
+    const settled = unsettled === -1 ? messages : messages.slice(0, unsettled);
+    const assembled = yield* preview3(db, sessionID, instructions, observed);
+    return {
+      initial: assembled.initial,
+      messages: settled.map((entry) => entry.message),
+      instructionUpdate: assembled.update
+    };
+  })).pipe(Effect.catch((error) => error instanceof InitializationBlocked2 ? error : Effect.die(error)));
+});
+var firstUserMessage2 = Effect.fn("SessionHistory.firstUserMessage")(function* (db, sessionID) {
+  const row = yield* db.select().from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, sessionID), eq(SessionMessageTable2.type, "user"))).orderBy(asc(SessionMessageTable2.seq)).get().pipe(Effect.orDie);
+  if (!row)
+    return;
+  const message = yield* decodeMessageRow2(row).pipe(Effect.orElseSucceed(() => {
+    return;
+  }));
+  return message?.type === "user" ? message : undefined;
+});
+
+export { latestCompaction2, decodeMessageRow2, load3, entriesForRunner2, preview2, firstUserMessage2, exports_history };

package/dist/chunks/{integration-f96gt2w1.js → command-57jd71w6.js}

@@ -1,33 +1,35 @@
 import {
-  exports_markdown
-} from "./integration-p5gyct0y.js";
+  ID6,
+  Service45
+} from "./command-cjy05afp.js";
 import {
-  exports_subagent_job
-} from "./integration-pps5gtkm.js";
+  Service68
+} from "./command-4jcgzkct.js";
 import {
-  exports_session
-} from "./integration-pj7nypz0.js";
+  Service57
+} from "./command-tr5yhgb5.js";
 import {
-  exports_config
-} from "./integration-q3j0tvwr.js";
+  Service62,
+  args2
+} from "./command-x0pd42vp.js";
 import {
-  exports_select
-} from "./integration-xvqr7khp.js";
+  Service19
+} from "./command-b89m47td.js";
 import {
-  exports_agent
-} from "./integration-e1kp6ed2.js";
+  make8
+} from "./command-b21g3jx5.js";
 import {
-  exports_location
-} from "./integration-gpa7n6yh.js";
+  parseOption2
+} from "./command-5daktx2q.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/config/plugin/command.ts
-var exports_command = {};
-__export(exports_command, {
-  ConfigCommandPlugin: () => exports_command,
-  Plugin: () => Plugin
+var exports_command2 = {};
+__export(exports_command2, {
+  ConfigCommandPlugin: () => exports_command2,
+  Plugin: () => Plugin29
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { ConfigCommand } from "@opencode-ai/schema/config/command";
@@ -39,10 +41,10 @@ import { Effect, Option, PubSub, Schema, Stream } from "effect";
 import { ChildProcess } from "effect/unstable/process";
 import { FSUtil } from "@opencode-ai/util/fs-util";
 var decodeCommand = Schema.decodeUnknownOption(ConfigCommand.Info);
-var Plugin = define({
+var Plugin29 = define({
   id: "opencode.config.command",
   effect: Effect.fn(function* (ctx) {
-    const config = yield* exports_config.Service;
+    const config = yield* Service57;
     const fs = yield* FSUtil.Service;
     const loadEntry = Effect.fnUntraced(function* (entry) {
       if (entry.type === "document")
@@ -52,12 +54,12 @@ var Plugin = define({
       const commands = yield* loadDirectory(fs, entry.path);
       return [{ commands: Object.fromEntries(commands.map((command) => [command.name, command.info])) }];
     });
-    const location = yield* exports_location.Service;
+    const location = yield* Service68;
     const processes = yield* AppProcess.Service;
-    const shell = yield* exports_select.Service;
-    const sessions = yield* exports_session.Service;
-    const agents = yield* exports_agent.Service;
-    const subagents = yield* exports_subagent_job.make;
+    const shell = yield* Service62;
+    const sessions = yield* Service19;
+    const agents = yield* Service45;
+    const subagents = yield* make8;
     const load = Effect.fn("ConfigCommandPlugin.load")(function* () {
       return yield* Effect.forEach(yield* config.entries(), loadEntry).pipe(Effect.map((documents) => documents.flat()));
     });
@@ -78,7 +80,7 @@ var Plugin = define({
             name,
             description: command.description,
             execute: (input) => Effect.gen(function* () {
-              const agent = command.agent === undefined ? undefined : exports_agent.ID.make(command.agent);
+              const agent = command.agent === undefined ? undefined : ID6.make(command.agent);
               const commandAgent = agent === undefined ? undefined : (yield* ctx.agent.get({ agentID: agent })).data;
               const model = command.model === undefined ? commandAgent?.model : {
                 id: Model.ID.make(command.model.model),
@@ -150,7 +152,7 @@ function loadDirectory(fs, directory) {
   });
 }
 function decode(directory, filepath, content) {
-  const markdown = exports_markdown.parseOption(content);
+  const markdown = parseOption2(content);
   if (!markdown)
     return;
   const info = Option.getOrUndefined(decodeCommand({ ...markdown.data, template: markdown.content.trim() }));
@@ -185,7 +187,7 @@ ${input}`.trim() : withArguments.trim();
     const shell = yield* services.shell.resolve({ priority: "config" });
     const outputs = yield* Effect.forEach(matches, (match) => {
       const source = match[1] ?? "";
-      return services.processes.run(ChildProcess.make(shell, exports_select.args(shell, source), {
+      return services.processes.run(ChildProcess.make(shell, args2(shell, source), {
         cwd: services.location.directory,
         stdin: "ignore"
       }), { combineOutput: true }).pipe(Effect.map((result) => (result.output ?? Buffer.concat([result.stdout, result.stderr])).toString("utf8")), Effect.mapError((error) => new Error(`Shell interpolation failed for ${JSON.stringify(source)}: ${error.message}`)));
@@ -202,4 +204,4 @@ var placeholderRegex = /\$(\d+)/g;
 var quoteTrimRegex = /^["']|["']$/g;
 var shellRegex = /!`([^`]+)`/g;
 
-export { Plugin, exports_command };
+export { Plugin29, exports_command2 };

package/dist/chunks/{integration-knk175w9.js → command-58dzf215.js}

@@ -1,26 +1,27 @@
 import {
-  RipgrepBinary
-} from "./integration-rahat93a.js";
+  NonNegativeInt2,
+  PositiveInt2,
+  RelativePath2
+} from "./command-p8qxwesx.js";
 import {
-  exports_environment1 as exports_environment
-} from "./integration-xckxf18q.js";
+  Service55,
+  node57
+} from "./command-4y9deqpk.js";
 import {
-  NonNegativeInt,
-  PositiveInt,
-  RelativePath
-} from "./integration-j07kk359.js";
+  RipgrepBinary2
+} from "./command-5jvc5tg2.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/ripgrep.ts
 var exports_ripgrep = {};
 __export(exports_ripgrep, {
-  Error: () => Error,
-  InvalidPatternError: () => InvalidPatternError,
+  Error: () => Error4,
+  InvalidPatternError: () => InvalidPatternError2,
   Ripgrep: () => exports_ripgrep,
-  Service: () => Service,
-  node: () => node
+  Service: () => Service54,
+  node: () => node56
 });
 import { Context, Effect, Fiber, Layer, Schema, Stream } from "effect";
 import { ChildProcess } from "effect/unstable/process";
@@ -34,37 +35,37 @@ var RawMatch = Schema.Struct({
   data: Schema.Struct({
     path: Schema.Struct({ text: Schema.String }),
     lines: Schema.Struct({ text: Schema.String }),
-    line_number: PositiveInt,
-    absolute_offset: NonNegativeInt,
+    line_number: PositiveInt2,
+    absolute_offset: NonNegativeInt2,
     submatches: Schema.Array(Schema.Struct({
       match: Schema.Struct({ text: Schema.String }),
-      start: NonNegativeInt,
-      end: NonNegativeInt
+      start: NonNegativeInt2,
+      end: NonNegativeInt2
     }))
   })
 });
 var decodeJsonRecord = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
 
-class Error extends Schema.TaggedError()("Ripgrep.Error", {
+class Error4 extends Schema.TaggedError()("Ripgrep.Error", {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect())
 }) {
 }
 
-class InvalidPatternError extends Schema.TaggedError()("Ripgrep.InvalidPatternError", {
+class InvalidPatternError2 extends Schema.TaggedError()("Ripgrep.InvalidPatternError", {
   pattern: Schema.String,
   message: Schema.String
 }) {
 }
 
-class Service extends Context.Service()("@opencode/Ripgrep") {
+class Service54 extends Context.Service()("@opencode/Ripgrep") {
 }
-var failure = (message, cause) => new Error({ message, cause });
+var failure = (message, cause) => new Error4({ message, cause });
 var normalizePath = (value) => value.replace(/^(?:\.[\\/])+/u, "").replace(/^[\\/]+/u, "").replaceAll("\\", "/");
 var isInvalidPattern = (stderr) => stderr.includes("regex parse error") || stderr.includes("error parsing regex");
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const environment = yield* exports_environment.Service;
-  const binary = yield* RipgrepBinary.Service;
+var layer = Layer.effect(Service54, Effect.gen(function* () {
+  const environment = yield* Service55;
+  const binary = yield* RipgrepBinary2.Service;
   const run = (input) => {
     const program = Effect.scoped(Effect.gen(function* () {
       const handle = yield* environment.spawner.spawn(ChildProcess.make(yield* binary.filepath, input.args, { cwd: input.cwd, extendEnv: true, stdin: "ignore" }));
@@ -81,7 +82,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       const code = yield* handle.exitCode;
       const stderr = yield* Fiber.join(stderrFiber);
       if (input.pattern && code === 2 && isInvalidPattern(stderr)) {
-        return yield* new InvalidPatternError({ pattern: input.pattern, message: stderr.trim() });
+        return yield* new InvalidPatternError2({ pattern: input.pattern, message: stderr.trim() });
       }
       if (code !== 0 && code !== 1 && code !== 2) {
         return yield* failure(stderr.trim() || `ripgrep failed with code ${code}`);
@@ -89,9 +90,9 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       return code === 1 ? [] : rows;
     }));
     const abortable = input.signal ? program.pipe(Effect.raceFirst(waitForAbort(input.signal))) : program;
-    return abortable.pipe(Effect.mapError((cause) => cause instanceof Error || cause instanceof InvalidPatternError ? cause : failure("ripgrep execution failed", cause)));
+    return abortable.pipe(Effect.mapError((cause) => cause instanceof Error4 || cause instanceof InvalidPatternError2 ? cause : failure("ripgrep execution failed", cause)));
   };
-  return Service.of({
+  return Service54.of({
     glob: (input) => run({
       cwd: input.cwd,
       limit: input.limit,
@@ -107,7 +108,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       ],
       parse: (line) => Effect.succeed(normalizePath(line))
     }).pipe(Effect.map((result) => result.map((relative) => Entry.make({
-      path: RelativePath.make(relative),
+      path: RelativePath2.make(relative),
       type: "file"
     }))), Effect.catchTag("Ripgrep.InvalidPatternError", (cause) => Effect.fail(failure(cause.message, cause)))),
     find: (input) => run({
@@ -127,7 +128,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       parse: (line) => {
         const relative = normalizePath(line);
         return Effect.succeed(Entry.make({
-          path: RelativePath.make(relative),
+          path: RelativePath2.make(relative),
           type: "file"
         }));
       },
@@ -159,7 +160,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       }))
     }).pipe(Effect.map((result) => result.map((match) => Match.make({
       entry: Entry.make({
-        path: RelativePath.make(match.path.text),
+        path: RelativePath2.make(match.path.text),
         type: "file"
       }),
       line: match.line_number,
@@ -173,6 +174,6 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     }))))
   });
 }));
-var node = makeLocationNode({ service: Service, layer, deps: [exports_environment.node, RipgrepBinary.node] });
+var node56 = makeLocationNode({ service: Service54, layer, deps: [node57, RipgrepBinary2.node] });
 
-export { Error, InvalidPatternError, Service, node, exports_ripgrep };
+export { Error4, InvalidPatternError2, Service54, node56, exports_ripgrep };

package/dist/chunks/{integration-p5gyct0y.js → command-5daktx2q.js}

@@ -1,31 +1,31 @@
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-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/{integration-f2nhxfjt.js → command-5fmxt4p5.js}

@@ -1,12 +1,9 @@
 import {
-  createProviderPlugin
-} from "./integration-0zz82cjq.js";
-import {
-  __require
-} from "./integration-vpjkya7h.js";
+  createProviderPlugin2
+} from "./command-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/{integration-rahat93a.js → command-5jvc5tg2.js}

@@ -1,6 +1,6 @@
 import {
-  which
-} from "./integration-k3e42drn.js";
+  which2
+} from "./command-qaymkmh1.js";
 
 // src/ripgrep/binary.ts
 import path from "path";
@@ -13,7 +13,7 @@ import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
 import { httpClient } from "@opencode-ai/util/effect/app-node-platform";
 import { FSUtil } from "@opencode-ai/util/fs-util";
 import { Global } from "@opencode-ai/util/global";
-var RipgrepBinary;
+var RipgrepBinary2;
 ((RipgrepBinary) => {
   const VERSION = "15.1.0";
   const PLATFORM = {
@@ -34,7 +34,7 @@ var RipgrepBinary;
     const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
     const spawner = yield* ChildProcessSpawner;
     const global = yield* Global.Service;
-    const findExecutable = (name) => which(name, undefined, global.bin);
+    const findExecutable = (name) => which2(name, undefined, global.bin);
     const run = Effect.fnUntraced(function* (command, args) {
       const handle = yield* spawner.spawn(ChildProcess.make(command, args, { extendEnv: true, stdin: "ignore" }));
       const [stdout, stderr, code] = yield* Effect.all([
@@ -101,6 +101,6 @@ var RipgrepBinary;
     layer,
     deps: [FSUtil.node, Global.node, httpClient, CrossSpawnSpawner.node]
   });
-})(RipgrepBinary ||= {});
+})(RipgrepBinary2 ||= {});
 
-export { RipgrepBinary };
+export { RipgrepBinary2 };

package/dist/chunks/{integration-xe02v0q7.js → command-5k3f87xj.js}

@@ -1,21 +1,19 @@
 import {
-  exports_provider
-} from "./integration-68yag814.js";
-import {
-  __require
-} from "./integration-vpjkya7h.js";
+  isAISDK2,
+  packageName2
+} from "./command-4z6b0fg6.js";
 
 // src/plugin/provider/anthropic.ts
 import { Effect } from "effect";
 import { define } from "@opencode-ai/plugin/effect/plugin";
-var AnthropicPlugin = define({
+var AnthropicPlugin2 = define({
   id: "opencode.provider.anthropic",
   effect: Effect.fn(function* (ctx) {
     yield* ctx.catalog.transform((evt) => {
       for (const item of evt.provider.list()) {
-        if (!exports_provider.isAISDK(item.provider.package))
+        if (!isAISDK2(item.provider.package))
           continue;
-        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/anthropic")
+        if (packageName2(item.provider.package) !== "@ai-sdk/anthropic")
           continue;
         evt.provider.update(item.provider.id, (provider) => {
           provider.headers = {
@@ -34,4 +32,4 @@ var AnthropicPlugin = define({
   })
 });
 
-export { AnthropicPlugin };
+export { AnthropicPlugin2 };

package/dist/chunks/{integration-dkmkay92.js → command-5qd3pb7m.js}

@@ -1,9 +1,9 @@
 // src/filesystem/watcher-binding.ts
 import { createRequire } from "node:module";
-function load() {
+function load4() {
   const require2 = createRequire(import.meta.url);
   const libc = typeof OPENCODE_LIBC === "undefined" ? undefined : OPENCODE_LIBC;
   return require2(process.env.OPENCODE_PARCEL_WATCHER_PATH ?? `@parcel/watcher-${process.platform}-${process.arch}${process.platform === "linux" ? `-${libc || "glibc"}` : ""}`);
 }
 
-export { load };
+export { load4 };

package/dist/chunks/command-5rw6je3s.js

@@ -0,0 +1,7 @@
+// src/session/schema.ts
+import * as SessionSchema2 from "@opencode-ai/schema/session";
+import { Session } from "@opencode-ai/schema/session";
+var ID7 = Session.ID;
+var Info9 = Session.Info;
+
+export { ID7, Info9, SessionSchema2 };

package/dist/chunks/{integration-jar52fmb.js → command-5w9qjdt3.js}

@@ -1,18 +1,15 @@
 import {
-  exports_app
-} from "./integration-hs51b0fc.js";
+  useragent2
+} from "./command-55yvdk0c.js";
 import {
-  exports_provider
-} from "./integration-68yag814.js";
-import {
-  __require
-} from "./integration-vpjkya7h.js";
+  ID18
+} from "./command-4z6b0fg6.js";
 
 // src/plugin/provider/gitlab.ts
 import os from "os";
 import { Effect } from "effect";
 import { define } from "@opencode-ai/plugin/effect/plugin";
-var GitLabPlugin = define({
+var GitLabPlugin2 = define({
   id: "opencode.provider.gitlab",
   effect: Effect.fn(function* (ctx) {
     yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
@@ -24,7 +21,7 @@ var GitLabPlugin = define({
         instanceUrl: typeof evt.options.instanceUrl === "string" ? evt.options.instanceUrl : process.env.GITLAB_INSTANCE_URL ?? "https://gitlab.com",
         apiKey: typeof evt.options.apiKey === "string" ? evt.options.apiKey : process.env.GITLAB_TOKEN,
         aiGatewayHeaders: {
-          "User-Agent": `${exports_app.useragent(ctx.app)} gitlab-ai-provider/${mod.VERSION} (${os.platform()} ${os.release()}; ${os.arch()})`,
+          "User-Agent": `${useragent2(ctx.app)} gitlab-ai-provider/${mod.VERSION} (${os.platform()} ${os.release()}; ${os.arch()})`,
           "anthropic-beta": "context-1m-2025-08-07",
           ...evt.options.aiGatewayHeaders
         },
@@ -36,7 +33,7 @@ var GitLabPlugin = define({
       });
     }));
     yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
-      if (evt.model.providerID !== exports_provider.ID.gitlab)
+      if (evt.model.providerID !== ID18.gitlab)
         return;
       const featureFlags = typeof evt.options.featureFlags === "object" && evt.options.featureFlags ? evt.options.featureFlags : {};
       const id = evt.model.modelID ?? evt.model.id;
@@ -61,4 +58,4 @@ var GitLabPlugin = define({
   })
 });
 
-export { GitLabPlugin };
+export { GitLabPlugin2 };

package/dist/chunks/{integration-qf52r0wh.js → command-60q8mcwp.js}

@@ -1,32 +1,32 @@
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/plugin/instance.ts
-var exports_instance = {};
-__export(exports_instance, {
-  InstancePlugins: () => exports_instance,
-  Service: () => Service,
-  bound: () => bound,
-  node: () => node
+var exports_instance2 = {};
+__export(exports_instance2, {
+  InstancePlugins: () => exports_instance2,
+  Service: () => Service2,
+  bound: () => bound2,
+  node: () => node3
 });
 import { Context, Layer } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 
-class Service extends Context.Service()("@opencode/InstancePlugins") {
+class Service2 extends Context.Service()("@opencode/InstancePlugins") {
 }
-var node = makeLocationNode({
-  service: Service,
-  layer: bound([]),
+var node3 = makeLocationNode({
+  service: Service2,
+  layer: bound2([]),
   deps: []
 });
-function bound(plugins) {
+function bound2(plugins) {
   const duplicates = plugins.filter((plugin, index) => plugins.findIndex((other) => other.id === plugin.id) !== index);
   if (duplicates.length > 0) {
     throw new Error(`duplicate instance plugin ids: ${duplicates.map((plugin) => plugin.id).join(", ")}`);
   }
   const stamped = plugins.map((plugin) => ({ ...plugin, revision: "instance", source: { type: "sdk" } }));
-  return Layer.succeed(Service, Service.of({ all: () => stamped }));
+  return Layer.succeed(Service2, Service2.of({ all: () => stamped }));
 }
 
-export { Service, node, bound, exports_instance };
+export { Service2, node3, bound2, exports_instance2 };