@opencode/core 2.0.21 → 2.0.23

package/dist/chunks/{job-x01dckpp.js → generate-z872cvkj.js}

@@ -1,10 +1,10 @@
 import {
   Service83,
   node87
-} from "./job-vdqv4tww.js";
+} from "./generate-z8hrkqzq.js";
 import {
   __export
-} from "./job-9rqn6x4v.js";
+} from "./generate-9rqn6x4v.js";
 
 // src/form.ts
 var exports_form = {};
@@ -12,31 +12,31 @@ __export(exports_form, {
   AlreadyExistsError: () => AlreadyExistsError2,
   AlreadySettledError: () => AlreadySettledError2,
   Answer: () => Answer2,
-  Event: () => Event19,
+  Event: () => Event20,
   Field: () => Field2,
   Fields: () => Fields2,
   Form: () => exports_form,
-  ID: () => ID14,
-  Info: () => Info29,
+  ID: () => ID16,
+  Info: () => Info26,
   InvalidAnswerError: () => InvalidAnswerError2,
   InvalidFormError: () => InvalidFormError2,
   NotFoundError: () => NotFoundError10,
   Reply: () => Reply3,
-  Service: () => Service75,
+  Service: () => Service79,
   State: () => State3,
   When: () => When2,
   layer: () => layer25,
-  node: () => node79,
+  node: () => node83,
   validateAnswer: () => validateAnswer2,
   validateFields: () => validateFields2
 });
 import { Form } from "@opencode/schema/form";
 import { Cache, Context, Deferred, Duration, Effect, Exit, Layer, Option, Schema } from "effect";
 import { makeLocationNode } from "@opencode/util/effect/app-node";
-import { Event as Event19 } from "@opencode/schema/form";
+import { Event as Event20 } from "@opencode/schema/form";
 var RETENTION = Duration.minutes(10);
-var ID14 = Form.ID;
-var Info29 = Form.Info;
+var ID16 = Form.ID;
+var Info26 = Form.Info;
 var Field2 = Form.Field;
 var Fields2 = Form.Fields;
 var When2 = Form.When;
@@ -45,7 +45,7 @@ var Answer2 = Form.Answer;
 var Reply3 = Form.Reply;
 
 class NotFoundError10 extends Schema.TaggedError()("Form.NotFoundError", {
-  id: ID14
+  id: ID16
 }) {
   get message() {
     return `Form not found: ${this.id}`;
@@ -53,7 +53,7 @@ class NotFoundError10 extends Schema.TaggedError()("Form.NotFoundError", {
 }
 
 class AlreadySettledError2 extends Schema.TaggedError()("Form.AlreadySettledError", {
-  id: ID14
+  id: ID16
 }) {
   get message() {
     return `Form already settled: ${this.id}`;
@@ -61,7 +61,7 @@ class AlreadySettledError2 extends Schema.TaggedError()("Form.AlreadySettledErro
 }
 
 class AlreadyExistsError2 extends Schema.TaggedError()("Form.AlreadyExistsError", {
-  id: ID14
+  id: ID16
 }) {
   get message() {
     return `Form already exists: ${this.id}`;
@@ -69,7 +69,7 @@ class AlreadyExistsError2 extends Schema.TaggedError()("Form.AlreadyExistsError"
 }
 
 class InvalidAnswerError2 extends Schema.TaggedError()("Form.InvalidAnswerError", {
-  id: ID14,
+  id: ID16,
   message: Schema.String
 }) {
 }
@@ -79,9 +79,9 @@ class InvalidFormError2 extends Schema.TaggedError()("Form.InvalidFormError", {
 }) {
 }
 
-class Service75 extends Context.Service()("@opencode/Form") {
+class Service79 extends Context.Service()("@opencode/Form") {
 }
-var layer25 = Layer.effect(Service75, Effect.gen(function* () {
+var layer25 = Layer.effect(Service79, Effect.gen(function* () {
   const bus = yield* Service83;
   let closed = false;
   const forms = yield* Cache.makeWith(() => Effect.die(new Error("Form cache must be used via set/getSuccess, never get")), {
@@ -90,7 +90,7 @@ var layer25 = Layer.effect(Service75, Effect.gen(function* () {
   });
   const requireEntry = Effect.fn("Form.requireEntry")((id) => Cache.getSuccess(forms, id).pipe(Effect.flatMap((entry) => Effect.fromOption(entry, () => new NotFoundError10({ id })))));
   const create = Effect.fn("Form.create")((input) => Effect.uninterruptible(Effect.gen(function* () {
-    const id = input.id ?? ID14.create();
+    const id = input.id ?? ID16.create();
     const existing = yield* Cache.getSuccess(forms, id);
     if (Option.isSome(existing))
       return yield* new AlreadyExistsError2({ id });
@@ -162,9 +162,9 @@ var layer25 = Layer.effect(Service75, Effect.gen(function* () {
     closed = true;
   }).pipe(Effect.andThen(Cache.values(forms)), Effect.flatMap((entries) => Effect.forEach(Array.from(entries).filter((entry) => entry.state.status === "pending"), (entry) => cancel(entry.form.id).pipe(Effect.ignore), { discard: true })));
   yield* Effect.addFinalizer(() => close);
-  return Service75.of({ create, ask, get, list, state, reply, cancel, close });
+  return Service79.of({ create, ask, get, list, state, reply, cancel, close });
 }));
-var node79 = makeLocationNode({ service: Service75, layer: layer25, deps: [node87] });
+var node83 = makeLocationNode({ service: Service79, layer: layer25, deps: [node87] });
 function validateAnswer2(form, answer) {
   const fields = new Map(form.map((field) => [field.key, field]));
   for (const key of Object.keys(answer)) {
@@ -316,4 +316,4 @@ function isDateTime(value) {
   return !Number.isNaN(new Date(value).getTime());
 }
 
-export { ID14, Info29, Field2, Fields2, When2, State3, Answer2, Reply3, NotFoundError10, AlreadySettledError2, AlreadyExistsError2, InvalidAnswerError2, InvalidFormError2, Service75, layer25, node79, validateAnswer2, validateFields2, exports_form, Event19 };
+export { ID16, Info26, Field2, Fields2, When2, State3, Answer2, Reply3, NotFoundError10, AlreadySettledError2, AlreadyExistsError2, InvalidAnswerError2, InvalidFormError2, Service79, layer25, node83, validateAnswer2, validateFields2, exports_form, Event20 };

package/dist/chunks/{job-vdqv4tww.js → generate-z8hrkqzq.js}

@@ -1,17 +1,17 @@
 import {
   Service84,
   node88
-} from "./job-vsq07z0a.js";
+} from "./generate-6zp854ra.js";
 import {
   EventSequenceTable2,
   EventTable2
-} from "./job-2710q6r3.js";
+} from "./generate-2710q6r3.js";
 import {
   makeUnsafe2
-} from "./job-y71avatq.js";
+} from "./generate-dpkg50ah.js";
 import {
   __export
-} from "./job-9rqn6x4v.js";
+} from "./generate-9rqn6x4v.js";
 
 // src/bus.ts
 var exports_bus = {};

package/dist/chunks/{job-j543e7zy.js → generate-ze7rj9cq.js}

@@ -1,30 +1,30 @@
 import {
   latest2,
-  Service51
-} from "./job-f09mb087.js";
+  Service63
+} from "./generate-t3cgces8.js";
 import {
-  Service50
-} from "./job-95f1p06x.js";
+  Service68
+} from "./generate-jb9mn43j.js";
 import {
   observe2
-} from "./job-qsdy395h.js";
+} from "./generate-qsdy395h.js";
 import {
   __export
-} from "./job-9rqn6x4v.js";
+} from "./generate-9rqn6x4v.js";
 
 // src/config/plugin/shell.ts
 var exports_shell = {};
 __export(exports_shell, {
   ConfigShellPlugin: () => exports_shell,
-  Plugin: () => Plugin19
+  Plugin: () => Plugin35
 });
 import { define } from "@opencode/plugin/effect/plugin";
 import { Effect } from "effect";
-var Plugin19 = define({
+var Plugin35 = define({
   id: "opencode.config.shell",
   effect: Effect.fn(function* (ctx) {
-    const config = yield* Service51;
-    const shell = yield* Service50;
+    const config = yield* Service63;
+    const shell = yield* Service68;
     const loaded = yield* observe2(config, ctx.event, shell.reload());
     yield* shell.transform((editor) => {
       const configured = latest2(loaded.entries, "shell");
@@ -34,4 +34,4 @@ var Plugin19 = define({
   })
 });
 
-export { Plugin19, exports_shell };
+export { Plugin35, exports_shell };

package/dist/chunks/{job-mvksx64m.js → generate-zfs8ae4p.js}

@@ -5,17 +5,17 @@ import {
   renderInitial2,
   renderUpdate2,
   applyHashDelta2
-} from "./job-rhjbct0v.js";
+} from "./generate-s8d7rejh.js";
 import {
   SessionEvent2
-} from "./job-ec1grn59.js";
+} from "./generate-ec1grn59.js";
 import {
   InstructionBlobTable2,
   InstructionStateTable2
-} from "./job-z07pqspn.js";
+} from "./generate-9e5bzkjp.js";
 import {
   __export
-} from "./job-9rqn6x4v.js";
+} from "./generate-9rqn6x4v.js";
 
 // src/session/instruction-state.ts
 var exports_instruction_state = {};

package/dist/chunks/{job-qn4ba14w.js → generate-zmr78fwr.js}

@@ -1,15 +1,15 @@
 import {
   PositiveInt2
-} from "./job-922hggd3.js";
+} from "./generate-z5v4ffb3.js";
 import {
   __export
-} from "./job-9rqn6x4v.js";
+} from "./generate-9rqn6x4v.js";
 
 // src/v1/config/provider.ts
 var exports_provider2 = {};
 __export(exports_provider2, {
   ConfigProviderV1: () => exports_provider2,
-  Info: () => Info12,
+  Info: () => Info18,
   Model: () => Model2,
   ModelStatus: () => ModelStatus2
 });
@@ -61,7 +61,7 @@ var Model2 = Schema.Struct({
     disabled: Schema.optional(Schema.Boolean).annotate({ description: "Disable this variant for the model" })
   }), [Schema.Record(Schema.String, Schema.Any)])).annotate({ description: "Variant-specific configuration" }))
 });
-var Info12 = Schema.Struct({
+var Info18 = Schema.Struct({
   api: Schema.optional(Schema.String),
   name: Schema.optional(Schema.String),
   env: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
@@ -95,4 +95,4 @@ var Info12 = Schema.Struct({
   models: Schema.optional(Schema.Record(Schema.String, Model2))
 }).annotate({ identifier: "ProviderConfig" });
 
-export { ModelStatus2, Model2, Info12, exports_provider2 };
+export { ModelStatus2, Model2, Info18, exports_provider2 };

package/dist/chunks/{job-rk1r2hx8.js → generate-znsx74x0.js}

@@ -1,7 +1,7 @@
 import {
   isCheckpoint2,
   decode2
-} from "./job-f29mbr7f.js";
+} from "./generate-h9wp8z5w.js";
 
 // src/session/runner/to-llm-message.ts
 import {

package/dist/chunks/generate-zp2fsh7c.js

@@ -0,0 +1,381 @@
+import {
+  useragent2
+} from "./generate-gk28ph79.js";
+import {
+  Service83
+} from "./generate-z8hrkqzq.js";
+import {
+  ID15,
+  OAuth3,
+  Event19,
+  Service78
+} from "./generate-spja3q52.js";
+import {
+  key2
+} from "./generate-addxnjmp.js";
+import {
+  ID14,
+  MethodID2
+} from "./generate-r7pm0y1x.js";
+import {
+  which2
+} from "./generate-qaymkmh1.js";
+import {
+  ID13,
+  Service76
+} from "./generate-3edgjjmd.js";
+import {
+  ID12
+} from "./generate-94jj38jg.js";
+import {
+  iife2
+} from "./generate-1kg9ymc8.js";
+import {
+  configuredSettings2
+} from "./generate-0at0q6bk.js";
+
+// src/plugin/provider/azure.ts
+import { Clock, Effect, FiberHandle, Option, Schema, Semaphore, Stream } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { ChildProcess } from "effect/unstable/process";
+import { define } from "@opencode/plugin/effect/plugin";
+import { Form } from "@opencode/schema/form";
+import { AppProcess } from "@opencode/util/process";
+var cognitiveScope = "https://cognitiveservices.azure.com/.default";
+var foundryScope = "https://ai.azure.com/.default";
+var managementScope = "https://management.azure.com/.default";
+var methodID = MethodID2.make("azure-cli");
+var resourcePattern = /^[a-zA-Z0-9][a-zA-Z0-9-]*$/;
+var decodeJSON = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
+var decodeToken = Schema.decodeUnknownEffect(Schema.Struct({
+  accessToken: Schema.NonEmptyString,
+  expires_on: Schema.optional(Schema.Number),
+  expiresOn: Schema.optional(Schema.NonEmptyString)
+}));
+var ResourceDeployments = Schema.Struct({ data: Schema.Array(Schema.Unknown) });
+var decodeResourceDeployment = Schema.decodeUnknownOption(Schema.Struct({ id: Schema.NonEmptyString, model: Schema.NonEmptyString, status: Schema.String }));
+var ManagementDeployments = Schema.Struct({
+  value: Schema.Array(Schema.Unknown),
+  nextLink: Schema.optional(Schema.NonEmptyString)
+});
+var decodeManagementDeployment = Schema.decodeUnknownOption(Schema.Struct({
+  name: Schema.NonEmptyString,
+  properties: Schema.Struct({
+    model: Schema.Struct({ name: Schema.NonEmptyString }),
+    provisioningState: Schema.String
+  })
+}));
+var ResourceQuery = Schema.Struct({ query: Schema.String });
+var Resources = Schema.Struct({ data: Schema.Array(Schema.Struct({ id: Schema.NonEmptyString })) });
+function make8(endpoints = {
+  resource: (name) => `https://${name}.openai.azure.com/openai`,
+  management: "https://management.azure.com"
+}) {
+  return define({
+    id: "opencode.provider.azure",
+    effect: Effect.fn(function* (ctx) {
+      const configured = yield* configuredSettings2(ID13.azure);
+      const processes = yield* AppProcess.Service;
+      const bus = yield* Service83;
+      const credentials = yield* Service78;
+      const providers = yield* Service76;
+      const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+      const tokens = new Map;
+      const resourceIDs = new Map;
+      const loading = Semaphore.makeUnsafe(1);
+      const discovery = yield* FiberHandle.make();
+      const loaded = {};
+      const command = (args) => processes.run(ChildProcess.make("az", args, { extendEnv: true, stdin: "ignore" }), { timeout: "10 seconds" }).pipe(Effect.flatMap(AppProcess.requireSuccess), Effect.flatMap((result) => decodeJSON(result.stdout.toString("utf8"))));
+      const token = Effect.fn("AzurePlugin.token")(function* (scope) {
+        const now = yield* Clock.currentTimeMillis;
+        const cached = tokens.get(scope);
+        if (cached && cached.expires - now > 5 * 60000)
+          return cached;
+        const result = yield* command(["account", "get-access-token", "--scope", scope, "--output", "json"]).pipe(Effect.flatMap(decodeToken));
+        const expires = result.expires_on !== undefined ? result.expires_on * 1000 : Date.parse(result.expiresOn ?? "");
+        if (!Number.isFinite(expires))
+          return yield* Effect.fail(new Error("Azure CLI returned an invalid token expiration"));
+        const refreshed = { access: result.accessToken, expires };
+        tokens.set(scope, refreshed);
+        return refreshed;
+      });
+      const management = (request) => token(managementScope).pipe(Effect.flatMap((current) => http.execute(request.pipe(HttpClientRequest.bearerToken(current.access), HttpClientRequest.acceptJson, HttpClientRequest.setHeader("User-Agent", useragent2(ctx.app))))));
+      const available = Boolean(which2("az"));
+      const form = () => iife2(() => {
+        if (resolveResourceName(configured) || typeof configured?.baseURL === "string")
+          return;
+        return Form.Fields.make([
+          {
+            type: "string",
+            key: "resourceName",
+            title: "Enter Azure Resource Name",
+            placeholder: "e.g. my-models",
+            required: true
+          }
+        ]);
+      });
+      yield* ctx.integration.transform((editor) => {
+        editor.method.update({
+          integrationID: ID13.azure,
+          method: { type: "key", label: "API key", form: form() }
+        });
+        if (!available)
+          return;
+        editor.method.update({
+          integrationID: ID13.azure,
+          method: {
+            id: methodID,
+            type: "oauth",
+            label: "Microsoft Entra ID (Azure CLI)",
+            form: form()
+          },
+          authorize: (answer) => Effect.succeed({
+            mode: "auto",
+            url: "",
+            instructions: "Sign in with `az login` before continuing.",
+            callback: Effect.gen(function* () {
+              const resourceName = (typeof answer.resourceName === "string" ? answer.resourceName.trim() : "") || resolveResourceName(configured);
+              if (!resourceName)
+                return yield* Effect.fail(new Error("Azure resource name is required"));
+              const current = yield* token(cognitiveScope);
+              return OAuth3.make({
+                type: "oauth",
+                methodID,
+                access: current.access,
+                refresh: "azure-cli",
+                expires: current.expires,
+                metadata: { resourceName }
+              });
+            })
+          }),
+          refresh: (credential) => token(cognitiveScope).pipe(Effect.map((current) => OAuth3.make({ ...credential, access: current.access, expires: current.expires })))
+        });
+      });
+      const load = Effect.fn("AzurePlugin.load")(function* () {
+        const connection = yield* ctx.integration.connection.active(ID13.azure);
+        const stored = connection?.type === "credential" ? yield* credentials.get(ID15.make(connection.id)) : undefined;
+        return { connection, resource: credentialResource(stored?.value) };
+      });
+      const findResource = Effect.fn("AzurePlugin.findResource")(function* (resource) {
+        const response = yield* HttpClientRequest.post(`${endpoints.management}/providers/Microsoft.ResourceGraph/resources?api-version=2022-10-01`).pipe(HttpClientRequest.schemaBodyJson(ResourceQuery)({ query: resourceQuery(resource) }), Effect.flatMap(management), Effect.flatMap(HttpClientResponse.schemaBodyJson(Resources)), Effect.timeout("10 seconds"));
+        const id = response.data[0]?.id;
+        if (!id)
+          return yield* Effect.fail(new Error(`Azure resource "${resource}" was not found`));
+        return id;
+      });
+      const managementDeployments = Effect.fn("AzurePlugin.managementDeployments")(function* (resource) {
+        const key = resource.toLowerCase();
+        const id = resourceIDs.get(key) ?? (yield* findResource(resource));
+        resourceIDs.set(key, id);
+        const origin = new URL(endpoints.management).origin;
+        return yield* Stream.paginate(`${endpoints.management}${id}/deployments?api-version=2024-10-01`, (url) => management(HttpClientRequest.get(url)).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(ManagementDeployments)), Effect.timeout("10 seconds"), Effect.flatMap((response) => response.nextLink !== undefined && URL.parse(response.nextLink)?.origin !== origin ? Effect.fail(new Error("Azure returned a deployment page outside the management endpoint")) : Effect.succeed([
+          response.value.flatMap((raw) => {
+            const item = Option.getOrUndefined(decodeManagementDeployment(raw));
+            return item?.properties.provisioningState === "Succeeded" ? [{ name: item.name, model: item.properties.model.name }] : [];
+          }),
+          Option.fromNullishOr(response.nextLink)
+        ])))).pipe(Stream.runCollect, Effect.tapError(() => Effect.sync(() => resourceIDs.delete(key))));
+      });
+      const resourceDeployments = Effect.fn("AzurePlugin.resourceDeployments")(function* (url, credential) {
+        return yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson, HttpClientRequest.setHeader("User-Agent", useragent2(ctx.app)), credential.type === "key" ? HttpClientRequest.setHeader("api-key", credential.key) : HttpClientRequest.bearerToken(credential.access))).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(ResourceDeployments)), Effect.timeout("10 seconds"), Effect.map((response) => response.data.flatMap((raw) => {
+          const item = Option.getOrUndefined(decodeResourceDeployment(raw));
+          return item?.status === "succeeded" ? [{ name: item.id, model: item.model }] : [];
+        })));
+      });
+      const deployments = (url, resource, credential) => credential.type === "oauth" ? managementDeployments(resource).pipe(Effect.catch(() => resourceDeployments(url, credential))) : resourceDeployments(url, credential);
+      const rebind = () => loading.withPermit(Effect.gen(function* () {
+        const current = yield* load();
+        if (key2(current.connection) === key2(loaded.connection) && current.resource === loaded.resource)
+          return;
+        Object.assign(loaded, current, { url: undefined, deployments: undefined });
+        yield* ctx.provider.reload();
+      }));
+      const discover = Effect.fn("AzurePlugin.discover")(function* () {
+        const connection = loaded.connection;
+        const settings = (yield* providers.get(ID13.azure))?.settings;
+        const name = loaded.resource ?? resolveResourceName(settings);
+        const url = connection && name !== undefined && resourcePattern.test(name) && typeof settings?.baseURL !== "string" ? `${endpoints.resource(name)}/deployments?api-version=2022-12-01` : undefined;
+        if (loaded.connection !== connection)
+          return;
+        if (loaded.url !== url) {
+          loaded.url = url;
+          if (loaded.deployments) {
+            loaded.deployments = undefined;
+            yield* ctx.model.reload();
+          }
+        }
+        if (!connection || !name || !url)
+          return;
+        const credential = yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
+          return;
+        }));
+        if (!credential || credential.type === "oauth" && credential.methodID !== methodID)
+          return;
+        const found = yield* deployments(url, name, credential).pipe(Effect.map((list) => list.toSorted((a, b) => a.name.localeCompare(b.name))), Effect.catch((cause) => Effect.logWarning("failed to sync Azure deployments", { cause }).pipe(Effect.as(undefined))));
+        if (!found)
+          return;
+        if (loaded.connection !== connection || key2(connection) !== key2(yield* ctx.integration.connection.active(ID13.azure)))
+          return;
+        if (JSON.stringify(found) === JSON.stringify(loaded.deployments))
+          return;
+        const catalog = new Map(Array.from((yield* providers.snapshot()).records.get(ID13.azure)?.models.keys() ?? [], (id) => [
+          id.toLowerCase(),
+          id
+        ]));
+        const unmatched = found.filter((deployment) => !catalogModel(catalog, deployment));
+        if (unmatched.length > 0)
+          yield* Effect.logWarning("Azure deployments of models outside the catalog need explicit configuration", {
+            deployments: unmatched.map((deployment) => deployment.name)
+          });
+        loaded.deployments = found;
+        yield* ctx.model.reload();
+      });
+      const refresh = () => rebind().pipe(Effect.andThen(FiberHandle.run(discovery, discover())));
+      const resourceFor = (provider) => provider.id === ID13.azure ? loaded.resource ?? resolveResourceName(provider.settings) : resolveResourceName(provider.settings, loaded.resource);
+      Object.assign(loaded, yield* load());
+      yield* ctx.provider.transform((evt) => {
+        for (const item of evt.list()) {
+          if (item.provider.id !== ID13.azure && !item.provider.package.startsWith("@opencode/ai/providers/azure/"))
+            continue;
+          const resourceName = resourceFor(item.provider);
+          const websocket = responsesWebSocketCapable(item.provider);
+          if (!resourceName && !websocket)
+            continue;
+          evt.update(item.provider.id, (provider) => {
+            provider.settings = {
+              ...provider.settings,
+              ...resourceName === undefined ? {} : { resourceName },
+              ...websocket ? { transport: provider.settings?.transport ?? "websocket" } : {},
+              ...resourceName !== undefined && typeof provider.settings?.baseURL === "string" ? { baseURL: expandResourceName(provider.settings.baseURL, resourceName) } : {}
+            };
+          });
+        }
+        const item = evt.get(ID13.azure);
+        if (!item)
+          return;
+        evt.add({
+          info: item.provider,
+          models: Array.from(item.models.values()),
+          sourceConnection: loaded.connection
+        });
+      });
+      yield* ctx.model.transform((models) => {
+        for (const item of models.provider.list()) {
+          if (item.provider.id !== ID13.azure && !item.provider.package.startsWith("@opencode/ai/providers/azure/"))
+            continue;
+          const resourceName = resourceFor(item.provider);
+          for (const model of models.list(item.provider.id)) {
+            models.update(item.provider.id, model.id, (draft) => {
+              if (resourceName && typeof draft.settings?.baseURL === "string")
+                draft.settings.baseURL = expandResourceName(draft.settings.baseURL, resolveResourceName(draft.settings, resourceName) ?? resourceName);
+            });
+          }
+        }
+        if (!loaded.deployments)
+          return;
+        const catalog = models.list(ID13.azure);
+        const deployed = deployedModels(loaded.deployments, catalog);
+        for (const model of catalog) {
+          if (!deployed.has(model.id))
+            models.remove(ID13.azure, model.id);
+        }
+        for (const [id, model] of deployed) {
+          models.update(ID13.azure, id, (draft) => Object.assign(draft, model));
+        }
+      });
+      yield* bus.subscribe(Event19.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID14.make("azure")), Stream.runForEach(() => refresh()), Effect.forkScoped({ startImmediately: true }));
+      yield* refresh().pipe(Effect.forkScoped);
+      const bearer = Effect.fn("AzurePlugin.bearer")(function* (url) {
+        const connection = yield* ctx.integration.connection.active(ID13.azure);
+        const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
+          return;
+        })) : undefined;
+        if (credential?.type !== "oauth" || credential.methodID !== methodID)
+          return;
+        const target = new URL(url);
+        const scope = target.hostname.endsWith(".services.ai.azure.com") && !target.pathname.startsWith("/models") ? foundryScope : cognitiveScope;
+        const current = yield* token(scope).pipe(Effect.orDie);
+        return `Bearer ${current.access}`;
+      });
+      yield* ctx.session.hook("http.request", (evt) => Effect.gen(function* () {
+        if (evt.model.providerID !== ID13.azure)
+          return;
+        const authorization = yield* bearer(evt.request.url);
+        if (!authorization)
+          return;
+        evt.request.headers.delete("api-key");
+        evt.request.headers.delete("x-api-key");
+        evt.request.headers.set("authorization", authorization);
+        evt.request.headers.set("user-agent", useragent2(ctx.app));
+      }), { providerID: ID13.azure });
+      yield* ctx.session.hook("experimental.ws.handshake", (evt) => Effect.gen(function* () {
+        if (evt.model.providerID !== ID13.azure)
+          return;
+        const authorization = yield* bearer(evt.url);
+        if (!authorization)
+          return;
+        delete evt.headers["api-key"];
+        delete evt.headers["x-api-key"];
+        evt.headers.authorization = authorization;
+        evt.headers["user-agent"] = useragent2(ctx.app);
+      }), { providerID: ID13.azure });
+    })
+  });
+}
+var AzurePlugin2 = make8();
+function resolveResourceName(settings, fallback) {
+  const configured = settings?.resourceName;
+  if (typeof configured === "string" && configured.trim() !== "")
+    return configured;
+  return fallback ?? process.env.AZURE_RESOURCE_NAME ?? process.env.AZURE_COGNITIVE_SERVICES_RESOURCE_NAME;
+}
+function expandResourceName(baseURL, resourceName) {
+  return baseURL.replaceAll("${AZURE_RESOURCE_NAME}", resourceName).replaceAll("${AZURE_COGNITIVE_SERVICES_RESOURCE_NAME}", resourceName);
+}
+function credentialResource(credential) {
+  const resource = credential?.type === "key" ? credential.configuration?.resourceName : credential?.methodID === methodID ? credential.metadata?.resourceName : undefined;
+  return typeof resource === "string" && resource.trim() !== "" ? resource : undefined;
+}
+function resourceQuery(resource) {
+  return [
+    "resources",
+    "| where type =~ 'microsoft.cognitiveservices/accounts' and kind in~ ('AIServices', 'OpenAI')",
+    "| extend resourceName = tostring(properties.customSubDomainName)",
+    `| where resourceName =~ '${resource}'`,
+    "| project id",
+    "| take 1"
+  ].join(" ");
+}
+function deployedModels(deployments, catalog) {
+  const models = new Map(catalog.map((model) => [model.id.toLowerCase(), model]));
+  return new Map(deployments.flatMap((deployment) => {
+    const model = catalogModel(models, deployment);
+    if (!model)
+      return [];
+    const id = ID12.make(deployment.name.toLowerCase());
+    const info = {
+      ...structuredClone(model),
+      id,
+      modelID: ID12.make(deployment.name),
+      name: id === model.id.toLowerCase() ? model.name : `${model.name} (${deployment.name})`
+    };
+    return [[id, info]];
+  }));
+}
+function catalogModel(models, deployment) {
+  return models.get(deployment.model.toLowerCase()) ?? models.get(deployment.name.toLowerCase());
+}
+function responsesWebSocketCapable(provider) {
+  if (provider.package !== "@opencode/ai/providers/azure/responses")
+    return false;
+  const settings = provider.settings;
+  if (settings?.useDeploymentBasedUrls === true)
+    return false;
+  if (settings?.apiVersion !== undefined && settings.apiVersion !== "v1")
+    return false;
+  if (typeof settings?.baseURL !== "string")
+    return true;
+  return /^https:\/\/[^/]+\.openai\.azure\.com(?:\/|$)/i.test(settings.baseURL);
+}
+
+export { make8, AzurePlugin2 };