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

package/dist/chunks/event-logger-yfbd16n1.js

@@ -0,0 +1,386 @@
+import {
+  SessionMessage2
+} from "./event-logger-982e01ww.js";
+import {
+  __export
+} from "./event-logger-9rqn6x4v.js";
+
+// src/session/message-updater.ts
+var exports_message_updater = {};
+__export(exports_message_updater, {
+  SessionMessageUpdater: () => exports_message_updater,
+  update: () => update2
+});
+import { castDraft, produce } from "immer";
+import { DateTime, Effect, Match, pipe, Schema } from "effect";
+var projectTerminalSnapshot = (draft, event) => {
+  if (event.data.snapshot || event.data.files)
+    draft.snapshot = {
+      ...draft.snapshot,
+      end: event.data.snapshot,
+      files: event.data.files ? Array.from(event.data.files) : undefined
+    };
+};
+function update2(adapter, event) {
+  const created = DateTime.makeUnsafe(event.created);
+  const latestTool = (assistant, id) => assistant.content.findLast((item) => item.type === "tool" && item.id === id);
+  const latestText = (assistant) => assistant.content.findLast((item) => item.type === "text");
+  const latestReasoning = (assistant) => assistant.content.findLast((item) => item.type === "reasoning" && !item.time?.completed);
+  const updateOwnedAssistant = (messageID, recipe) => Effect.gen(function* () {
+    const assistant = yield* adapter.getAssistant(messageID);
+    if (!assistant)
+      return;
+    yield* adapter.updateAssistant(produce(assistant, recipe));
+  });
+  const clearCurrentRetry = Effect.gen(function* () {
+    const assistant = yield* adapter.getCurrentAssistant();
+    if (!assistant?.retry)
+      return;
+    yield* adapter.updateAssistant(produce(assistant, (draft) => {
+      draft.retry = undefined;
+    }));
+  });
+  const project = pipe(Match.type(), Match.discriminatorsExhaustive("type")({
+    "session.created": () => Effect.void,
+    "session.viewed": () => Effect.void,
+    "session.message.content.updated": (event) => updateOwnedAssistant(event.data.messageID, (draft) => {
+      draft.content = castDraft(Schema.decodeUnknownSync(Schema.Array(SessionMessage2.AssistantContent))(event.data.content));
+    }),
+    "session.usage.recorded": () => Effect.void,
+    "session.agent.selected": (event) => Effect.gen(function* () {
+      const previous = event.data.previous ?? (yield* adapter.getAgent());
+      yield* adapter.appendMessage(SessionMessage2.AgentSelected.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "agent-switched",
+        metadata: event.metadata,
+        agent: event.data.agent,
+        previous,
+        time: { created }
+      }));
+    }),
+    "session.model.selected": (event) => Effect.gen(function* () {
+      const previous = event.data.previous ?? (yield* adapter.getModel());
+      yield* adapter.appendMessage(SessionMessage2.ModelSelected.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "model-switched",
+        metadata: event.metadata,
+        model: event.data.model,
+        previous,
+        time: { created }
+      }));
+    }),
+    "session.moved": (event) => Effect.gen(function* () {
+      yield* adapter.appendMessage(SessionMessage2.LocationSwitched.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "location-switched",
+        metadata: event.metadata,
+        location: event.data.location,
+        projectID: event.data.projectID,
+        subpath: event.data.subpath,
+        previous: yield* adapter.getLocation(),
+        time: { created }
+      }));
+    }),
+    "session.renamed": () => Effect.void,
+    "session.deleted": () => Effect.void,
+    "session.forked": () => Effect.void,
+    "session.inbox.delivered": () => Effect.void,
+    "session.inbox.enqueued": () => Effect.void,
+    "session.inbox.cancelled": () => Effect.void,
+    "session.inbox.delivery.changed": () => Effect.void,
+    "session.execution.started": () => Effect.void,
+    "session.execution.succeeded": () => clearCurrentRetry,
+    "session.execution.failed": () => clearCurrentRetry,
+    "session.execution.interrupted": () => clearCurrentRetry,
+    "session.instructions.updated": (event) => {
+      if (event.data.text === undefined)
+        return Effect.void;
+      return adapter.appendMessage(SessionMessage2.System.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "system",
+        text: event.data.text,
+        description: `Instructions updated: ${Object.keys(event.data.delta).join(", ")}`,
+        metadata: event.metadata,
+        time: { created }
+      }));
+    },
+    "session.synthetic": (event) => {
+      return adapter.appendMessage(SessionMessage2.Synthetic.make({
+        text: event.data.text,
+        description: event.data.description,
+        metadata: event.data.metadata,
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "synthetic",
+        time: { created }
+      }));
+    },
+    "session.skill.activated": (event) => {
+      return adapter.appendMessage(SessionMessage2.Skill.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "skill",
+        skill: event.data.id,
+        name: event.data.name,
+        text: event.data.text,
+        metadata: event.metadata,
+        time: { created }
+      }));
+    },
+    "session.shell.started": (event) => {
+      return adapter.appendMessage(SessionMessage2.Shell.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "shell",
+        metadata: event.data.shell.metadata.background === true ? { ...event.metadata, background: true } : event.metadata,
+        shellID: event.data.shell.id,
+        command: event.data.shell.command,
+        status: event.data.shell.status,
+        time: { created }
+      }));
+    },
+    "session.shell.ended": (event) => Effect.gen(function* () {
+      const currentShell = yield* adapter.getShell(event.data.shell.id);
+      if (currentShell) {
+        yield* adapter.updateShell(produce(currentShell, (draft) => {
+          draft.status = event.data.shell.status;
+          draft.exit = event.data.shell.exit;
+          draft.output = event.data.output;
+          draft.time.completed = created;
+        }));
+      }
+    }),
+    "session.step.started": (event) => Effect.gen(function* () {
+      const existing = yield* adapter.getAssistant(event.data.assistantMessageID);
+      if (existing) {
+        yield* adapter.updateAssistant(produce(existing, (draft) => {
+          draft.agent = event.data.agent;
+          draft.model = castDraft(event.data.model);
+          draft.retry = undefined;
+          draft.error = undefined;
+          draft.finish = undefined;
+          draft.rawFinish = undefined;
+          draft.providerState = undefined;
+          draft.time.streamed = undefined;
+          draft.time.completed = undefined;
+          if (event.data.snapshot)
+            draft.snapshot = { ...draft.snapshot, start: event.data.snapshot };
+        }));
+        return;
+      }
+      const currentAssistant = yield* adapter.getCurrentAssistant();
+      if (currentAssistant) {
+        yield* adapter.updateAssistant(produce(currentAssistant, (draft) => {
+          draft.retry = undefined;
+          draft.time.completed = created;
+        }));
+      }
+      yield* adapter.appendMessage(SessionMessage2.Assistant.make({
+        id: event.data.assistantMessageID,
+        type: "assistant",
+        agent: event.data.agent,
+        model: event.data.model,
+        metadata: event.metadata,
+        time: { created },
+        content: [],
+        snapshot: event.data.snapshot ? { start: event.data.snapshot } : undefined
+      }));
+    }),
+    "session.step.streamed": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.time.streamed = created;
+      });
+    },
+    "session.step.ended": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.time.completed = created;
+        draft.finish = event.data.finish;
+        draft.rawFinish = event.data.rawFinish;
+        draft.providerState = castDraft(event.data.providerState);
+        draft.cost = event.data.cost;
+        draft.tokens = event.data.tokens;
+        projectTerminalSnapshot(draft, event);
+      });
+    },
+    "session.step.failed": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.time.completed = created;
+        draft.finish = event.data.finish ?? "error";
+        draft.rawFinish = event.data.rawFinish;
+        draft.providerState = castDraft(event.data.providerState);
+        draft.error = castDraft(event.data.error);
+        draft.retry = undefined;
+        if (event.data.cost !== undefined && event.data.tokens !== undefined) {
+          draft.cost = event.data.cost;
+          draft.tokens = castDraft(event.data.tokens);
+        }
+        projectTerminalSnapshot(draft, event);
+      });
+    },
+    "session.text.started": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.content.push(castDraft(SessionMessage2.AssistantText.make({ type: "text", text: "" })));
+      });
+    },
+    "session.text.ended": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestText(draft);
+        if (match) {
+          match.text = event.data.text;
+          match.state = castDraft(event.data.state);
+        }
+      });
+    },
+    "session.tool.input.started": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.content.push(castDraft(SessionMessage2.AssistantTool.make({
+          type: "tool",
+          id: event.data.id,
+          name: event.data.name,
+          time: { created },
+          state: SessionMessage2.ToolStateStreaming.make({ status: "streaming", input: "" })
+        })));
+      });
+    },
+    "session.tool.input.ended": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestTool(draft, event.data.id);
+        if (match && match.state.status === "streaming")
+          match.state.input = event.data.text;
+      });
+    },
+    "session.tool.called": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestTool(draft, event.data.id);
+        if (match) {
+          match.executed = event.data.executed;
+          match.providerState = event.data.state;
+          match.time.ran = created;
+          match.state = castDraft(SessionMessage2.ToolStateRunning.make({
+            status: "running",
+            input: event.data.input,
+            metadata: {}
+          }));
+        }
+      });
+    },
+    "session.tool.success": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestTool(draft, event.data.id);
+        if (match && match.state.status === "running") {
+          match.executed = event.data.executed || match.executed === true;
+          match.providerResultState = event.data.resultState;
+          match.time.completed = created;
+          match.state = castDraft(SessionMessage2.ToolStateCompleted.make({
+            status: "completed",
+            input: match.state.input,
+            content: event.data.content,
+            ...event.data.metadata === undefined ? {} : { metadata: event.data.metadata }
+          }));
+        }
+      });
+    },
+    "session.tool.failed": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestTool(draft, event.data.id);
+        if (match && (match.state.status === "streaming" || match.state.status === "running")) {
+          match.executed = event.data.executed || match.executed === true;
+          match.providerResultState = event.data.resultState;
+          match.time.completed = created;
+          match.state = castDraft(SessionMessage2.ToolStateError.make({
+            status: "error",
+            error: event.data.error,
+            input: typeof match.state.input === "string" ? {} : match.state.input,
+            ...event.data.content === undefined ? {} : { content: event.data.content },
+            ...event.data.metadata === undefined ? {} : { metadata: event.data.metadata }
+          }));
+        }
+      });
+    },
+    "session.reasoning.started": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.content.push(castDraft(SessionMessage2.AssistantReasoning.make({
+          type: "reasoning",
+          text: "",
+          state: event.data.state,
+          time: { created }
+        })));
+      });
+    },
+    "session.reasoning.ended": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        const match = latestReasoning(draft);
+        if (match) {
+          match.text = event.data.text;
+          match.time = { created: match.time?.created ?? created, completed: created };
+          if (event.data.state !== undefined)
+            match.state = event.data.state;
+        }
+      });
+    },
+    "session.retry.scheduled": (event) => {
+      return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+        draft.retry = {
+          attempt: event.data.attempt,
+          at: DateTime.makeUnsafe(event.data.at),
+          error: castDraft(event.data.error)
+        };
+      });
+    },
+    "session.compaction.started": (event) => adapter.appendMessage(SessionMessage2.CompactionRunning.make({
+      id: event.data.inputID ?? SessionMessage2.ID.fromEvent(event.id),
+      type: "compaction",
+      status: "running",
+      metadata: event.metadata,
+      reason: event.data.reason,
+      summary: "",
+      recent: event.data.recent ?? "",
+      time: { created }
+    })),
+    "session.compaction.ended": (event) => Effect.gen(function* () {
+      const current = yield* adapter.getCompaction();
+      if (current?.status === "running") {
+        yield* adapter.updateCompaction({
+          ...current,
+          status: "completed",
+          reason: event.data.reason,
+          model: event.data.model,
+          providerState: event.data.providerState,
+          summary: event.data.text,
+          recent: event.data.recent
+        });
+        return;
+      }
+      yield* adapter.appendMessage(SessionMessage2.Compaction.make({
+        id: SessionMessage2.ID.fromEvent(event.id),
+        type: "compaction",
+        status: "completed",
+        metadata: event.metadata,
+        reason: event.data.reason,
+        model: event.data.model,
+        providerState: event.data.providerState,
+        summary: event.data.text,
+        recent: event.data.recent,
+        time: { created }
+      }));
+    }),
+    "session.compaction.failed": (event) => Effect.gen(function* () {
+      const current = yield* adapter.getCompaction();
+      const failed = SessionMessage2.CompactionFailed.make({
+        id: current?.id ?? event.data.inputID ?? SessionMessage2.ID.fromEvent(event.id),
+        type: "compaction",
+        status: "failed",
+        metadata: current?.metadata ?? event.metadata,
+        reason: event.data.reason,
+        error: event.data.error,
+        time: current?.time ?? { created }
+      });
+      if (current?.status === "running")
+        return yield* adapter.updateCompaction(failed);
+      yield* adapter.appendMessage(failed);
+    }),
+    "session.revert.staged": () => Effect.void,
+    "session.revert.cleared": () => Effect.void,
+    "session.revert.committed": () => Effect.void
+  }));
+  return project(event);
+}
+
+export { update2, exports_message_updater };

package/dist/chunks/event-logger-yhtqjkzd.js

@@ -0,0 +1,20 @@
+import {
+  __export
+} from "./event-logger-9rqn6x4v.js";
+
+// src/instance/service.ts
+var exports_service2 = {};
+__export(exports_service2, {
+  Instance: () => exports_service2,
+  Service: () => Service33,
+  node: () => node36
+});
+import { Context } from "effect";
+import { Node } from "@opencode-ai/util/effect/app-node";
+import { LayerNode } from "@opencode-ai/util/effect/layer-node";
+
+class Service33 extends Context.Service()("@opencode/Instance") {
+}
+var node36 = LayerNode.unbound(Service33, Node.tags.values.global);
+
+export { Service33, node36, exports_service2 };

package/dist/chunks/{schema-gfvhypam.js → event-logger-yj1cwwh1.js}

@@ -1,30 +1,30 @@
 import {
-  exports_entry_observer
-} from "./schema-mnyszbxc.js";
+  Service48
+} from "./event-logger-47b3sbnz.js";
 import {
-  exports_image
-} from "./schema-22x56hdn.js";
+  Service55
+} from "./event-logger-rt2rznzy.js";
 import {
-  exports_config
-} from "./schema-jq0ga1pd.js";
+  observe2
+} from "./event-logger-qsdy395h.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/config/plugin/image.ts
-var exports_image2 = {};
-__export(exports_image2, {
-  ConfigImagePlugin: () => exports_image2,
-  Plugin: () => Plugin
+var exports_image = {};
+__export(exports_image, {
+  ConfigImagePlugin: () => exports_image,
+  Plugin: () => Plugin39
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect } from "effect";
-var Plugin = define({
+var Plugin39 = define({
   id: "opencode.config.image",
   effect: Effect.fn(function* (ctx) {
-    const config = yield* exports_config.Service;
-    const image = yield* exports_image.Service;
-    const loaded = yield* exports_entry_observer.observe(config, ctx.event, image.reload());
+    const config = yield* Service48;
+    const image = yield* Service55;
+    const loaded = yield* observe2(config, ctx.event, image.reload());
     yield* image.transform((editor) => {
       for (const entry of loaded.entries) {
         if (entry.type !== "document")
@@ -43,4 +43,4 @@ var Plugin = define({
   })
 });
 
-export { Plugin, exports_image2 as exports_image };
+export { Plugin39, exports_image };

package/dist/chunks/{schema-serjdnzw.js → event-logger-yjj59j99.js}

@@ -1,26 +1,29 @@
 import {
-  exports_kv
-} from "./schema-y2b04s9v.js";
+  ephemeral2,
+  Service79,
+  node84
+} from "./event-logger-jbmjz4v3.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  Service64,
+  node68
+} from "./event-logger-1vjz4200.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/wellknown.ts
 var exports_wellknown = {};
 __export(exports_wellknown, {
-  Auth: () => Auth,
-  Config: () => Config,
-  Event: () => Event,
-  Manifest: () => Manifest,
-  RemoteConfig: () => RemoteConfig,
-  Service: () => Service,
+  Auth: () => Auth2,
+  Config: () => Config2,
+  Event: () => Event10,
+  Manifest: () => Manifest2,
+  RemoteConfig: () => RemoteConfig2,
+  Service: () => Service51,
   WellKnown: () => exports_wellknown,
-  inspect: () => inspect,
-  node: () => node,
-  resolve: () => resolve
+  inspect: () => inspect2,
+  node: () => node54,
+  resolve: () => resolve2
 });
 import { Integration } from "@opencode-ai/schema/integration";
 import { Context, Effect, Layer, Ref, Schema, Semaphore } from "effect";
@@ -28,33 +31,33 @@ import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstab
 import { isDeepStrictEqual } from "node:util";
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
 import { httpClient } from "@opencode-ai/util/effect/app-node-platform";
-var Auth = Schema.Struct({
+var Auth2 = Schema.Struct({
   command: Schema.Array(Schema.String),
   env: Schema.String
 }).annotate({ identifier: "WellKnown.Auth" });
-var RemoteConfig = Schema.Struct({
+var RemoteConfig2 = Schema.Struct({
   url: Schema.String,
   headers: Schema.optional(Schema.Record(Schema.String, Schema.String))
 }).annotate({ identifier: "WellKnown.RemoteConfig" });
-var Config = Schema.Record(Schema.String, Schema.Json).annotate({ identifier: "WellKnown.Config" });
-var Manifest = Schema.Struct({
-  auth: Schema.optional(Auth),
-  config: Schema.optional(Schema.NullOr(Config)),
-  remote_config: Schema.optional(RemoteConfig)
+var Config2 = Schema.Record(Schema.String, Schema.Json).annotate({ identifier: "WellKnown.Config" });
+var Manifest2 = Schema.Struct({
+  auth: Schema.optional(Auth2),
+  config: Schema.optional(Schema.NullOr(Config2)),
+  remote_config: Schema.optional(RemoteConfig2)
 }).annotate({ identifier: "WellKnown.Manifest" });
 
-class Service extends Context.Service()("@opencode/WellKnown") {
+class Service51 extends Context.Service()("@opencode/WellKnown") {
 }
-var Event = {
-  Updated: exports_bus.ephemeral({ type: "wellknown.updated", schema: {} })
+var Event10 = {
+  Updated: ephemeral2({ type: "wellknown.updated", schema: {} })
 };
-var inspect = Effect.fn("WellKnown.inspect")(function* (origin) {
+var inspect2 = Effect.fn("WellKnown.inspect")(function* (origin) {
   const url = `${origin.replace(/\/+$/, "")}/.well-known/opencode`;
   const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
-  return yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson)).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Manifest)), Effect.mapError((cause) => new Error(`Failed to load wellknown manifest from ${url}`, { cause })));
+  return yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson)).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Manifest2)), Effect.mapError((cause) => new Error(`Failed to load wellknown manifest from ${url}`, { cause })));
 });
-var resolve = Effect.fn("WellKnown.resolve")(function* (input) {
-  const manifest = yield* inspect(input.origin);
+var resolve2 = Effect.fn("WellKnown.resolve")(function* (input) {
+  const manifest = yield* inspect2(input.origin);
   return yield* resolveEntry({ origin: input.origin, integrationID: Integration.ID.make(input.origin.replace(/\/+$/, "")), manifest }, input.variables ?? {});
 });
 var resolveEntry = Effect.fnUntraced(function* (entry, variables) {
@@ -65,21 +68,21 @@ var resolveEntry = Effect.fnUntraced(function* (entry, variables) {
   const url = substitute(entry.manifest.remote_config.url);
   const headers = Object.fromEntries(Object.entries(entry.manifest.remote_config.headers ?? {}).map(([key, value]) => [key, substitute(value)]));
   const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
-  const remote = yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson, HttpClientRequest.setHeaders(headers))).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Config)), Effect.mapError((cause) => new Error(`Failed to load wellknown remote config from ${url}`, { cause })));
-  if (Schema.is(Config)(remote.config))
+  const remote = yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson, HttpClientRequest.setHeaders(headers))).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Config2)), Effect.mapError((cause) => new Error(`Failed to load wellknown remote config from ${url}`, { cause })));
+  if (Schema.is(Config2)(remote.config))
     return [...configs, remote.config];
   return [...configs, remote];
 });
 var sourcesKey = "wellknown:sources";
 var Sources = Schema.Array(Schema.String);
-var layer = Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service51, Effect.gen(function* () {
   const http = yield* HttpClient.HttpClient;
-  const kv = yield* exports_kv.Service;
-  const bus = yield* exports_bus.Service;
+  const kv = yield* Service64;
+  const bus = yield* Service79;
   const cache = yield* Ref.make(new Map);
   const lock = Semaphore.makeUnsafe(1);
   const loadEntry = Effect.fn("WellKnown.loadEntry")(function* (origin) {
-    const manifest = yield* inspect(origin).pipe(Effect.provideService(HttpClient.HttpClient, http));
+    const manifest = yield* inspect2(origin).pipe(Effect.provideService(HttpClient.HttpClient, http));
     return { origin, integrationID: Integration.ID.make(origin), manifest };
   });
   const load = Effect.fn("WellKnown.load")(function* () {
@@ -106,10 +109,10 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     if (!changed)
       return false;
     yield* Ref.set(cache, next);
-    yield* bus.publish(Event.Updated, {});
+    yield* bus.publish(Event10.Updated, {});
     return true;
   }, (effect) => lock.withPermit(effect));
-  return Service.of({
+  return Service51.of({
     entries: load,
     snapshot: () => Array.from(Ref.getUnsafe(cache).values()),
     refresh,
@@ -122,7 +125,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       const origins = Schema.is(Sources)(sources) ? sources : [];
       yield* kv.set(sourcesKey, Array.from(new Set([...origins, origin])));
       yield* Ref.update(cache, (current) => new Map(current).set(origin, entry));
-      yield* bus.publish(Event.Updated, {});
+      yield* bus.publish(Event10.Updated, {});
       return entry;
     }, (effect, _value) => lock.withPermit(effect)),
     remove: Effect.fn("WellKnown.remove")(function* (value) {
@@ -135,11 +138,11 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         next.delete(origin);
         return next;
       });
-      yield* bus.publish(Event.Updated, {});
+      yield* bus.publish(Event10.Updated, {});
     }, (effect, _value) => lock.withPermit(effect)),
     resolve: Effect.fn("WellKnown.resolveEntry")((entry, variables) => resolveEntry(entry, variables).pipe(Effect.provideService(HttpClient.HttpClient, http)))
   });
 }));
-var node = makeGlobalNode({ service: Service, layer, deps: [httpClient, exports_kv.node, exports_bus.node] });
+var node54 = makeGlobalNode({ service: Service51, layer, deps: [httpClient, node68, node84] });
 
-export { Auth, RemoteConfig, Config, Manifest, Service, Event, inspect, resolve, node, exports_wellknown };
+export { Auth2, RemoteConfig2, Config2, Manifest2, Service51, Event10, inspect2, resolve2, node54, exports_wellknown };

package/dist/chunks/{schema-jar52fmb.js → event-logger-yn9v8pzf.js}

@@ -1,18 +1,15 @@
 import {
-  exports_app
-} from "./schema-hs51b0fc.js";
+  useragent2
+} from "./event-logger-fd84j5ds.js";
 import {
-  exports_provider
-} from "./schema-68yag814.js";
-import {
-  __require
-} from "./schema-vpjkya7h.js";
+  ID11
+} from "./event-logger-rwbhhn1p.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 !== ID11.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 };