@opencode-ai/core 0.0.0-beta-18600 → 0.0.0-beta-18707

package/dist/chunks/{project-gy9zm4ck.js → model-vwkfg4n5.js}

@@ -1,17 +1,17 @@
 import {
   EventSequenceTable,
   EventTable
-} from "./project-zsf8rs93.js";
+} from "./model-zsf8rs93.js";
 import {
   exports_database
-} from "./project-gcc0jgqv.js";
+} from "./model-rrbd0qbq.js";
 import {
   exports_keyed_mutex
-} from "./project-0kvmztkf.js";
+} from "./model-0kvmztkf.js";
 import {
   __export,
   __require
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/bus.ts
 var exports_bus = {};
@@ -161,103 +161,101 @@ function configured(options) {
       function commitDurableEvent(definition, event, input, commit) {
         return Effect.gen(function* () {
           const durable2 = definition.durable;
-          if (durable2) {
-            const aggregateID = event.data[durable2.aggregate];
-            if (typeof aggregateID !== "string") {
-              yield* Effect.die(new InvalidDurableEventError({
-                type: event.type,
-                message: `Expected string aggregate field ${durable2.aggregate}`
-              }));
-            } else {
-              if (input && input.aggregateID !== aggregateID) {
+          if (!durable2)
+            return yield* Effect.void;
+          const aggregateID = event.data[durable2.aggregate];
+          if (typeof aggregateID !== "string")
+            return yield* Effect.die(new InvalidDurableEventError({
+              type: event.type,
+              message: `Expected string aggregate field ${durable2.aggregate}`
+            }));
+          if (input && input.aggregateID !== aggregateID) {
+            yield* Effect.die(new InvalidDurableEventError({
+              type: event.type,
+              message: `Aggregate mismatch: expected ${input.aggregateID}, got ${aggregateID}`
+            }));
+          }
+          const list = projectors.get(versionedType(definition.type, durable2.version)) ?? [];
+          return yield* Effect.uninterruptible(Effect.gen(function* () {
+            const committed = yield* db.transaction(() => Effect.gen(function* () {
+              const row = yield* db.select({ seq: EventSequenceTable.seq, ownerID: EventSequenceTable.owner_id }).from(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
+              const latest = row?.seq ?? -1;
+              const encoded = Schema.encodeUnknownSync(definition.data)(event.data);
+              if (input?.strictOwner && row?.ownerID && row.ownerID !== input.ownerID) {
                 yield* Effect.die(new InvalidDurableEventError({
                   type: event.type,
-                  message: `Aggregate mismatch: expected ${input.aggregateID}, got ${aggregateID}`
+                  message: `Replay owner mismatch for aggregate ${aggregateID}: expected ${row.ownerID}, got ${input.ownerID ?? "none"}`
                 }));
               }
-              const list = projectors.get(versionedType(definition.type, durable2.version)) ?? [];
-              return yield* Effect.uninterruptible(Effect.gen(function* () {
-                const committed = yield* db.transaction(() => Effect.gen(function* () {
-                  const row = yield* db.select({ seq: EventSequenceTable.seq, ownerID: EventSequenceTable.owner_id }).from(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
-                  const latest = row?.seq ?? -1;
-                  const encoded = Schema.encodeUnknownSync(definition.data)(event.data);
-                  if (input?.strictOwner && row?.ownerID && row.ownerID !== input.ownerID) {
-                    yield* Effect.die(new InvalidDurableEventError({
-                      type: event.type,
-                      message: `Replay owner mismatch for aggregate ${aggregateID}: expected ${row.ownerID}, got ${input.ownerID ?? "none"}`
-                    }));
+              if (input && input.seq <= latest) {
+                if (!persist)
+                  return;
+                const stored = yield* db.select().from(EventTable).where(and(eq(EventTable.aggregate_id, aggregateID), eq(EventTable.seq, input.seq))).get().pipe(Effect.orDie);
+                if (stored?.id === event.id && stored.type === versionedType(definition.type, durable2.version) && stored.created === (event.created ?? 0) && isDeepStrictEqual(stored.data, encoded)) {
+                  if (input.ownerID && row?.ownerID == null) {
+                    yield* db.update(EventSequenceTable).set({ owner_id: input.ownerID }).where(eq(EventSequenceTable.aggregate_id, aggregateID)).run().pipe(Effect.orDie);
                   }
-                  if (input && input.seq <= latest) {
-                    if (!persist)
-                      return;
-                    const stored = yield* db.select().from(EventTable).where(and(eq(EventTable.aggregate_id, aggregateID), eq(EventTable.seq, input.seq))).get().pipe(Effect.orDie);
-                    if (stored?.id === event.id && stored.type === versionedType(definition.type, durable2.version) && stored.created === (event.created ?? 0) && isDeepStrictEqual(stored.data, encoded)) {
-                      if (input.ownerID && row?.ownerID == null) {
-                        yield* db.update(EventSequenceTable).set({ owner_id: input.ownerID }).where(eq(EventSequenceTable.aggregate_id, aggregateID)).run().pipe(Effect.orDie);
-                      }
-                      return;
-                    }
-                    yield* Effect.die(new InvalidDurableEventError({
-                      type: event.type,
-                      message: `Replay diverged at aggregate ${aggregateID} sequence ${input.seq}`
-                    }));
-                  }
-                  if (input && row?.ownerID && row.ownerID !== input.ownerID) {
-                    return;
-                  }
-                  const seq = input?.seq ?? latest + 1;
-                  if (input && seq !== latest + 1) {
-                    yield* Effect.die(new InvalidDurableEventError({
-                      type: event.type,
-                      message: `Sequence mismatch for aggregate ${aggregateID}: expected ${latest + 1}, got ${seq}`
-                    }));
-                  }
-                  if (persist) {
-                    const stored = yield* db.select({ aggregateID: EventTable.aggregate_id, seq: EventTable.seq }).from(EventTable).where(eq(EventTable.id, event.id)).get().pipe(Effect.orDie);
-                    if (stored)
-                      yield* Effect.die(new InvalidDurableEventError({
-                        type: event.type,
-                        message: `Event ${event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`
-                      }));
-                  }
-                  const committed2 = {
-                    ...event,
-                    durable: { aggregateID, seq, version: durable2.version }
-                  };
-                  const route = yield* prepareRoutes([committed2]);
-                  for (const projector of list) {
-                    yield* projector(committed2);
-                  }
-                  if (commit)
-                    yield* commit(seq);
-                  yield* db.insert(EventSequenceTable).values([{ aggregate_id: aggregateID, seq, owner_id: input?.ownerID }]).onConflictDoUpdate({
-                    target: EventSequenceTable.aggregate_id,
-                    set: {
-                      seq: sql`max(${EventSequenceTable.seq}, ${seq})`,
-                      ...input?.ownerID && row?.ownerID == null ? { owner_id: input.ownerID } : {}
-                    }
-                  }).run().pipe(Effect.orDie);
-                  if (persist)
-                    yield* db.insert(EventTable).values([
-                      {
-                        id: event.id,
-                        aggregate_id: aggregateID,
-                        seq,
-                        created: event.created ?? 0,
-                        type: versionedType(definition.type, durable2.version),
-                        data: encoded
-                      }
-                    ]).run().pipe(Effect.orDie);
-                  return { aggregateID, seq, event: committed2, route };
-                }), { behavior: "immediate" }).pipe(Effect.orDie);
-                if (committed) {
-                  committed.route();
-                  yield* Effect.forEach(pubsub.durable.get(committed.aggregateID) ?? [], (wake) => PubSub.publish(wake, undefined), { discard: true });
+                  return;
                 }
-                return committed;
-              }));
+                yield* Effect.die(new InvalidDurableEventError({
+                  type: event.type,
+                  message: `Replay diverged at aggregate ${aggregateID} sequence ${input.seq}`
+                }));
+              }
+              if (input && row?.ownerID && row.ownerID !== input.ownerID) {
+                return;
+              }
+              const seq = input?.seq ?? latest + 1;
+              if (input && seq !== latest + 1) {
+                yield* Effect.die(new InvalidDurableEventError({
+                  type: event.type,
+                  message: `Sequence mismatch for aggregate ${aggregateID}: expected ${latest + 1}, got ${seq}`
+                }));
+              }
+              if (persist) {
+                const stored = yield* db.select({ aggregateID: EventTable.aggregate_id, seq: EventTable.seq }).from(EventTable).where(eq(EventTable.id, event.id)).get().pipe(Effect.orDie);
+                if (stored)
+                  yield* Effect.die(new InvalidDurableEventError({
+                    type: event.type,
+                    message: `Event ${event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`
+                  }));
+              }
+              const committed2 = {
+                ...event,
+                durable: { aggregateID, seq, version: durable2.version }
+              };
+              const route = yield* prepareRoutes([committed2]);
+              for (const projector of list) {
+                yield* projector(committed2);
+              }
+              if (commit)
+                yield* commit(seq);
+              yield* db.insert(EventSequenceTable).values([{ aggregate_id: aggregateID, seq, owner_id: input?.ownerID }]).onConflictDoUpdate({
+                target: EventSequenceTable.aggregate_id,
+                set: {
+                  seq: sql`max(${EventSequenceTable.seq}, ${seq})`,
+                  ...input?.ownerID && row?.ownerID == null ? { owner_id: input.ownerID } : {}
+                }
+              }).run().pipe(Effect.orDie);
+              if (persist)
+                yield* db.insert(EventTable).values([
+                  {
+                    id: event.id,
+                    aggregate_id: aggregateID,
+                    seq,
+                    created: event.created ?? 0,
+                    type: versionedType(definition.type, durable2.version),
+                    data: encoded
+                  }
+                ]).run().pipe(Effect.orDie);
+              return { aggregateID, seq, event: committed2, route };
+            }), { behavior: "immediate" }).pipe(Effect.orDie);
+            if (committed) {
+              committed.route();
+              yield* Effect.forEach(pubsub.durable.get(committed.aggregateID) ?? [], (wake) => PubSub.publish(wake, undefined), { discard: true });
             }
-          }
+            return committed;
+          }));
         });
       }
       function publishEvent(definition, event, commit) {
@@ -507,10 +505,10 @@ function configured(options) {
           aggregateID: input.aggregateID,
           ...target >= 0 ? { seq: Event.Seq.make(target) } : {}
         };
-        const replay2 = readThrough(target).pipe(Stream.map((event) => event), Stream.concat(Stream.make(marker)));
+        const replay2 = readThrough(target).pipe(Stream.concat(Stream.make(marker)));
         if (!wakes)
           return replay2;
-        const live = Stream.fromSubscription(wakes).pipe(Stream.mapEffect(() => latestSequence(db, input.aggregateID)), Stream.filter((target2) => target2 > sequence), Stream.flatMap((target2) => readThrough(target2)), Stream.map((event) => event));
+        const live = Stream.fromSubscription(wakes).pipe(Stream.mapEffect(() => latestSequence(db, input.aggregateID)), Stream.filter((target2) => target2 > sequence), Stream.flatMap((target2) => readThrough(target2)));
         return Stream.concat(replay2, live);
       }));
       const listen = (listener) => Effect.sync(() => {

package/dist/chunks/{project-vz89hfgr.js → model-vz89hfgr.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/vcs/patch.ts
 var exports_patch = {};

package/dist/chunks/{project-h12kt9pa.js → model-w385wtt6.js}

@@ -1,9 +1,9 @@
 import {
   exports_provider
-} from "./project-krsqcmnj.js";
+} from "./model-fex42j86.js";
 import {
   __require
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/plugin/provider/anthropic.ts
 import { Effect } from "effect";

package/dist/chunks/{project-wbkt8qpj.js → model-wbkt8qpj.js}

@@ -1,7 +1,7 @@
 import {
   getViewSelectedFieldsRuntime,
   orderSelectedFields
-} from "./project-k8b45nas.js";
+} from "./model-k8b45nas.js";
 
 // src/database/drizzle/sqlite-core/effect/select.ts
 import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";

package/dist/chunks/{project-qxpt6zan.js → model-wf85cm54.js}

@@ -1,45 +1,45 @@
+import {
+  exports_instruction_entry
+} from "./model-hd3n7xxs.js";
 import {
   exports_message_updater
-} from "./project-2knkewgs.js";
+} from "./model-ngz3v23c.js";
 import {
   exports_inbox
-} from "./project-ayrkq19e.js";
-import {
-  exports_instruction_entry
-} from "./project-yq1fxjb2.js";
+} from "./model-kvhsphac.js";
 import {
   exports_instruction_state
-} from "./project-0687t5rp.js";
+} from "./model-hxcd35r2.js";
 import {
   SessionInboxTable,
   SessionMessageTable,
   SessionTable
-} from "./project-q606pcse.js";
-import {
-  Slug
-} from "./project-df3v2q6j.js";
+} from "./model-q606pcse.js";
 import {
   SessionMessage
-} from "./project-8rpfd2h6.js";
+} from "./model-8rpfd2h6.js";
 import {
   SessionEvent
-} from "./project-a83yvq99.js";
+} from "./model-a83yvq99.js";
+import {
+  Slug
+} from "./model-df3v2q6j.js";
 import {
   ProjectTable
-} from "./project-c8ya26sa.js";
+} from "./model-c8ya26sa.js";
 import {
   AbsolutePath,
   RelativePath
-} from "./project-j07kk359.js";
+} from "./model-j07kk359.js";
 import {
   exports_bus
-} from "./project-gy9zm4ck.js";
+} from "./model-vwkfg4n5.js";
 import {
   exports_database
-} from "./project-gcc0jgqv.js";
+} from "./model-rrbd0qbq.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/session/projector.ts
 var exports_projector = {};

package/dist/chunks/{project-ssk1zpcb.js → model-wj5aszjk.js}

@@ -1,22 +1,22 @@
 import {
   ID
-} from "./project-tvmhrvfj.js";
-import {
-  exports_select
-} from "./project-bbhffenw.js";
+} from "./model-tvmhrvfj.js";
 import {
   lazy
-} from "./project-8w9tzfz1.js";
+} from "./model-8w9tzfz1.js";
 import {
   exports_location
-} from "./project-pm12wdxj.js";
+} from "./model-xy3y21dp.js";
+import {
+  exports_select
+} from "./model-bbhffenw.js";
 import {
   exports_bus
-} from "./project-gy9zm4ck.js";
+} from "./model-vwkfg4n5.js";
 import {
   __export,
   __require
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/pty.ts
 var exports_pty = {};
@@ -54,7 +54,7 @@ class ExitedError extends Schema.TaggedError()("Pty.ExitedError", {
 
 class Service extends Context.Service()("@opencode/Pty") {
 }
-var layer = () => Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service, Effect.gen(function* () {
   const bus = yield* exports_bus.Service;
   const location = yield* exports_location.Service;
   const shell = yield* exports_select.Service;
@@ -269,7 +269,7 @@ var layer = () => Layer.effect(Service, Effect.gen(function* () {
 }));
 var node = makeLocationNode({
   service: Service,
-  layer: layer(),
+  layer,
   deps: [exports_bus.node, exports_location.node, exports_select.node]
 });
 

package/dist/chunks/{project-y68gmye4.js → model-wk5ccvwp.js}

@@ -1,39 +1,39 @@
 import {
   exports_runner
-} from "./project-2m0hgr65.js";
-import {
-  exports_inbox
-} from "./project-ayrkq19e.js";
+} from "./model-2m0hgr65.js";
 import {
   exports_run_coordinator
-} from "./project-7khw64yh.js";
+} from "./model-41qzzbpz.js";
+import {
+  exports_inbox
+} from "./model-kvhsphac.js";
 import {
   toSessionError
-} from "./project-8xpa4rfs.js";
+} from "./model-zvgnemsv.js";
+import {
+  exports_job
+} from "./model-ys131sm2.js";
 import {
   exports_store
-} from "./project-vjmn5wwb.js";
+} from "./model-bym1j60d.js";
 import {
   UserInterruptedError
-} from "./project-fb7nfzf2.js";
+} from "./model-cgqn2mrm.js";
 import {
-  exports_job
-} from "./project-86t2edmb.js";
+  SessionEvent
+} from "./model-a83yvq99.js";
 import {
   exports_location_service_map
-} from "./project-zdkg1k91.js";
-import {
-  SessionEvent
-} from "./project-a83yvq99.js";
+} from "./model-zdkg1k91.js";
 import {
   exports_bus
-} from "./project-gy9zm4ck.js";
+} from "./model-vwkfg4n5.js";
 import {
   exports_database
-} from "./project-gcc0jgqv.js";
+} from "./model-rrbd0qbq.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/session/execution.ts
 var exports_execution = {};
@@ -105,6 +105,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   });
   return Service.of({
     active: coordinator.active,
+    isActive: coordinator.isActive,
     interrupt: (sessionID, options) => Effect.gen(function* () {
       const interrupted = yield* coordinator.interrupt(sessionID, "user");
       if (!options?.continue)
@@ -128,6 +129,7 @@ var node = makeGlobalNode({
 });
 var noopLayer = Layer.succeed(Service, Service.of({
   active: Effect.succeed(new Set),
+  isActive: () => Effect.succeed(false),
   resume: () => Effect.void,
   wake: () => Effect.void,
   interrupt: () => Effect.succeed(false),

package/dist/chunks/{project-wmxdh12w.js → model-wmxdh12w.js}

@@ -1,6 +1,6 @@
 import {
   Timestamps
-} from "./project-sem2g21k.js";
+} from "./model-sem2g21k.js";
 
 // src/kv/sql.ts
 import { sqliteTable, text } from "drizzle-orm/sqlite-core";

package/dist/chunks/{project-1r30nvhb.js → model-wngq0b9r.js}

@@ -1,12 +1,12 @@
 import {
   exports_reference
-} from "./project-qxsjpy8c.js";
+} from "./model-pywyq33w.js";
 import {
   exports_instructions
-} from "./project-ec8vrfw5.js";
+} from "./model-ec8vrfw5.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/reference/instructions.ts
 var exports_instructions2 = {};

package/dist/chunks/{project-wps8gh8n.js → model-wps8gh8n.js}

@@ -1,9 +1,9 @@
 import {
   createProviderPlugin
-} from "./project-0zz82cjq.js";
+} from "./model-0zz82cjq.js";
 import {
   __require
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/plugin/provider/perplexity.ts
 var PerplexityPlugin = createProviderPlugin({

package/dist/chunks/{project-5cdnkd94.js → model-wq5r9j83.js}

@@ -1,12 +1,9 @@
-import {
-  exports_model
-} from "./project-r13w8t0w.js";
 import {
   exports_provider
-} from "./project-krsqcmnj.js";
+} from "./model-fex42j86.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/plugin/variant.ts
 var exports_variant = {};
@@ -17,6 +14,7 @@ __export(exports_variant, {
 });
 import { Effect } from "effect";
 import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Model } from "@opencode-ai/schema/model";
 var Plugin = define({
   id: "opencode.variant",
   effect: Effect.fn(function* (ctx) {
@@ -48,7 +46,7 @@ function generate(model, provider) {
   if (!["glm-5.2", "glm-5-2", "glm-5p2"].some((name) => ids.includes(name)))
     return [];
   return ["high", "max"].map((id) => ({
-    id: exports_model.VariantID.make(id),
+    id: Model.VariantID.make(id),
     settings: { reasoningEffort: id }
   }));
 }

package/dist/chunks/{project-hs6h3an3.js → model-x3gnmkmq.js}

@@ -1,96 +1,96 @@
 import {
   OpencodePlugin
-} from "./project-n08k8xnm.js";
+} from "./model-1zqcfpgf.js";
 import {
-  CoherePlugin
-} from "./project-qe0d689s.js";
+  NvidiaPlugin
+} from "./model-kww0mg52.js";
 import {
-  GoogleVertexPlugin
-} from "./project-0gcqkg3x.js";
+  OpenRouterPlugin
+} from "./model-4h896fer.js";
 import {
-  OpenAIPlugin
-} from "./project-fw21zw5n.js";
+  CoherePlugin
+} from "./model-qe0d689s.js";
 import {
-  CerebrasPlugin
-} from "./project-2wds5nk3.js";
+  OpenAIPlugin
+} from "./model-cre7gbc6.js";
 import {
-  VercelPlugin
-} from "./project-tgbb2ckq.js";
+  XAIPlugin
+} from "./model-7drm3h8s.js";
 import {
   ZenmuxPlugin
-} from "./project-awg5d31a.js";
-import {
-  AnthropicPlugin
-} from "./project-h12kt9pa.js";
-import {
-  KiloPlugin
-} from "./project-enpg66yn.js";
-import {
-  OpenAICompatiblePlugin
-} from "./project-mxvw03gv.js";
+} from "./model-npwkm078.js";
 import {
   PerplexityPlugin
-} from "./project-wps8gh8n.js";
+} from "./model-wps8gh8n.js";
 import {
   MistralPlugin
-} from "./project-3thh6229.js";
-import {
-  SnowflakeCortexPlugin
-} from "./project-fgyjabww.js";
+} from "./model-3thh6229.js";
 import {
   VLLMPlugin
-} from "./project-tjzkemh8.js";
+} from "./model-j760n82t.js";
 import {
-  AlibabaPlugin
-} from "./project-4zzdwbaz.js";
-import {
-  GatewayPlugin
-} from "./project-smpeg8c9.js";
+  VercelPlugin
+} from "./model-02f9w0t0.js";
 import {
   LMStudioPlugin
-} from "./project-2tnd1ag8.js";
+} from "./model-c14t2hjy.js";
 import {
-  GithubCopilotPlugin
-} from "./project-szqzwjp8.js";
+  GitLabPlugin
+} from "./model-0d4mk87s.js";
 import {
-  VenicePlugin
-} from "./project-xwftk1fd.js";
+  CloudflareAIGatewayPlugin
+} from "./model-x881kgek.js";
+import {
+  DynamicProviderPlugin
+} from "./model-s2kjqxd3.js";
+import {
+  SapAICorePlugin
+} from "./model-gz9s6gpj.js";
 import {
   CloudflareWorkersAIPlugin
-} from "./project-9twaxxs3.js";
+} from "./model-sdcaysy0.js";
+import {
+  GoogleVertexPlugin
+} from "./model-rdqmt1vp.js";
 import {
   AmazonBedrockPlugin
-} from "./project-m55whf0h.js";
+} from "./model-q66tjefk.js";
 import {
-  DynamicProviderPlugin
-} from "./project-s2kjqxd3.js";
+  VenicePlugin
+} from "./model-xwftk1fd.js";
 import {
-  GitLabPlugin
-} from "./project-j0sncrp4.js";
+  AlibabaPlugin
+} from "./model-4zzdwbaz.js";
 import {
-  XAIPlugin
-} from "./project-t16napr0.js";
+  OpenAICompatiblePlugin
+} from "./model-mxvw03gv.js";
 import {
   LLMGatewayPlugin
-} from "./project-tpx671s8.js";
+} from "./model-q9vfn5x4.js";
 import {
-  OpenRouterPlugin
-} from "./project-8pngjawd.js";
+  SnowflakeCortexPlugin
+} from "./model-h6q26knr.js";
 import {
-  SapAICorePlugin
-} from "./project-83ba1yz6.js";
+  OllamaPlugin
+} from "./model-x8tgsatw.js";
 import {
-  AzurePlugin
-} from "./project-k2bjf35z.js";
+  KiloPlugin
+} from "./model-g68hwncr.js";
 import {
-  CloudflareAIGatewayPlugin
-} from "./project-60xr61qr.js";
+  CerebrasPlugin
+} from "./model-ps01fcq7.js";
 import {
-  NvidiaPlugin
-} from "./project-3qv8nf0b.js";
+  GithubCopilotPlugin
+} from "./model-b380beks.js";
 import {
-  OllamaPlugin
-} from "./project-3ngtzkgg.js";
+  AzurePlugin
+} from "./model-y9415wjy.js";
+import {
+  GatewayPlugin
+} from "./model-smpeg8c9.js";
+import {
+  AnthropicPlugin
+} from "./model-w385wtt6.js";
 
 // src/plugin/provider.ts
 var ProviderPlugins = [