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

package/dist/chunks/project-hxw68eqm.js

@@ -0,0 +1,187 @@
+import {
+  exports_protected
+} from "./project-kg1345f7.js";
+import {
+  exports_ripgrep
+} from "./project-8t2ap2vm.js";
+import {
+  exports_location
+} from "./project-pm12wdxj.js";
+import {
+  RelativePath
+} from "./project-j07kk359.js";
+import {
+  __export
+} from "./project-rvfvac9x.js";
+
+// src/filesystem/search.ts
+var exports_search = {};
+__export(exports_search, {
+  ripgrepLayer: () => ripgrepLayer,
+  node: () => node,
+  layer: () => layer,
+  fffLayer: () => fffLayer,
+  configured: () => configured,
+  Service: () => Service,
+  Options: () => Options,
+  FileSystemSearch: () => exports_search
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import path from "path";
+import { Clock, Context, Deferred, Duration, Effect, Layer, Schema, Scope } from "effect";
+import { Fff } from "#fff";
+import fuzzysort from "fuzzysort";
+import { FileSystem } from "@opencode-ai/schema/filesystem";
+var Options = Schema.Struct({
+  fff: Schema.optional(Schema.Boolean)
+});
+
+class Service extends Context.Service()("@opencode/FileSystem/Search") {
+}
+var REFRESH_INTERVAL = Duration.toMillis("10 seconds");
+function emptyIndex() {
+  return { files: new Map, directories: new Map };
+}
+function search(index, input) {
+  const items = input.type === "file" ? Array.from(index.files.values()) : input.type === "directory" ? Array.from(index.directories.values()) : [...index.files.values(), ...index.directories.values()];
+  const result = fuzzysort.go(input.query, items, { limit: input.limit ?? 50 });
+  fuzzysort.cleanup();
+  return result.map((item) => {
+    const relative = item.target;
+    const type = relative.endsWith(path.sep) ? "directory" : "file";
+    return FileSystem.Entry.make({
+      path: RelativePath.make(relative),
+      type
+    });
+  });
+}
+var ripgrepLayer = Layer.effect(Service, Effect.gen(function* () {
+  const location = yield* exports_location.Service;
+  const ripgrep = yield* exports_ripgrep.Service;
+  const scope = yield* Scope.Scope;
+  const clock = yield* Clock.Clock;
+  const home = exports_protected.isHome(location.directory);
+  let index = emptyIndex();
+  let initialized = false;
+  let settledAt = Number.NEGATIVE_INFINITY;
+  let refreshing;
+  const scan = Effect.gen(function* () {
+    const next = emptyIndex();
+    const previous = index;
+    if (!initialized)
+      index = next;
+    yield* ripgrep.find({
+      cwd: location.directory,
+      pattern: "*",
+      limit: location.vcs && !home ? Number.MAX_SAFE_INTEGER : 1e5,
+      exclude: home ? [...exports_protected.names()].map((name) => `${name}/**`) : undefined,
+      onEntry: (entry) => Effect.sync(() => {
+        next.files.set(entry.path, previous.files.get(entry.path) ?? fuzzysort.prepare(entry.path));
+        const parts = entry.path.split("/");
+        parts.slice(0, -1).forEach((_, offset) => {
+          const directory = parts.slice(0, offset + 1).join("/") + path.sep;
+          if (!next.directories.has(directory))
+            next.directories.set(directory, previous.directories.get(directory) ?? fuzzysort.prepare(directory));
+        });
+      })
+    });
+    index = next;
+    initialized = true;
+  }).pipe(Effect.orDie);
+  const refresh = Effect.suspend(() => {
+    if (refreshing)
+      return initialized ? Effect.void : Deferred.await(refreshing);
+    if (initialized && clock.currentTimeMillisUnsafe() < settledAt + REFRESH_INTERVAL)
+      return Effect.void;
+    const attempt = Deferred.makeUnsafe();
+    refreshing = attempt;
+    return scan.pipe(Effect.onExit((exit) => Effect.sync(() => {
+      settledAt = clock.currentTimeMillisUnsafe();
+      if (refreshing === attempt)
+        refreshing = undefined;
+      Deferred.doneUnsafe(attempt, exit);
+    })), Effect.forkIn(scope), Effect.flatMap(() => initialized ? Effect.void : Deferred.await(attempt)));
+  });
+  return Service.of({
+    find: (input) => Effect.gen(function* () {
+      yield* refresh;
+      return search(index, input);
+    })
+  });
+}));
+var fffLayer = Layer.effect(Service, Effect.gen(function* () {
+  const location = yield* exports_location.Service;
+  const result = yield* Effect.try({
+    try: () => Fff.create({
+      basePath: location.directory,
+      aiMode: true,
+      disableMmapCache: true,
+      disableContentIndexing: true
+    }),
+    catch: (cause) => cause
+  }).pipe(Effect.catch((error) => Effect.logWarning("failed to initialize fff", { error }).pipe(Effect.as(undefined))));
+  if (!result?.ok) {
+    if (result)
+      yield* Effect.logWarning("failed to initialize fff", { error: result.error });
+    return Service.of({
+      find: () => Effect.succeed([])
+    });
+  }
+  yield* Effect.addFinalizer(() => Effect.sync(() => result.value.destroy()));
+  return Service.of({
+    find: (input) => Effect.sync(() => {
+      const options = { pageIndex: 0, pageSize: input.limit ?? 50 };
+      const items = (() => {
+        if (input.type === "file") {
+          const found2 = result.value.fileSearch(input.query.trim(), options);
+          if (!found2.ok)
+            throw found2.error;
+          return found2.value.items.map((item, index) => ({
+            path: item.relativePath,
+            type: "file",
+            score: found2.value.scores[index]?.total ?? 0
+          }));
+        }
+        if (input.type === "directory") {
+          const found2 = result.value.directorySearch(input.query.trim(), options);
+          if (!found2.ok)
+            throw found2.error;
+          return found2.value.items.map((item, index) => ({
+            path: item.relativePath,
+            type: "directory",
+            score: found2.value.scores[index]?.total ?? 0
+          }));
+        }
+        const found = result.value.mixedSearch(input.query.trim(), options);
+        if (!found.ok)
+          throw found.error;
+        return found.value.items.map((item, index) => ({
+          path: item.item.relativePath,
+          type: item.type,
+          score: found.value.scores[index]?.total ?? 0
+        }));
+      })();
+      return items.sort((a, b) => b.score - a.score || a.path.length - b.path.length).map((item) => {
+        const relative = item.path.replaceAll("\\", "/").replace(/\/$/, "");
+        return FileSystem.Entry.make({
+          path: RelativePath.make(relative + (item.type === "directory" ? path.sep : "")),
+          type: item.type
+        });
+      });
+    })
+  });
+}));
+var layer = (options) => Layer.unwrap(Effect.gen(function* () {
+  const location = yield* exports_location.Service;
+  if (location.workspaceID)
+    return ripgrepLayer;
+  if (options?.fff === false || options?.fff === undefined && process.platform === "win32" || !Fff.available())
+    return ripgrepLayer;
+  return location.vcs && !exports_protected.isHome(location.directory) ? fffLayer : ripgrepLayer;
+}));
+function configured(options) {
+  return makeLocationNode({ service: Service, layer: layer(options), deps: [exports_location.node, exports_ripgrep.node] });
+}
+var node = configured();
+
+export { Options, Service, ripgrepLayer, fffLayer, layer, configured, node, exports_search };

package/dist/chunks/{tool-gpybhmhb.js → project-j0sncrp4.js}

@@ -1,12 +1,12 @@
 import {
   exports_app
-} from "./tool-50jxp3hw.js";
+} from "./project-50jxp3hw.js";
 import {
   exports_provider
-} from "./tool-krsqcmnj.js";
+} from "./project-krsqcmnj.js";
 import {
   __require
-} from "./tool-rvfvac9x.js";
+} from "./project-rvfvac9x.js";
 
 // src/plugin/provider/gitlab.ts
 import os from "os";
@@ -41,7 +41,7 @@ var GitLabPlugin = define({
       const featureFlags = typeof evt.options.featureFlags === "object" && evt.options.featureFlags ? evt.options.featureFlags : {};
       const id = evt.model.modelID ?? evt.model.id;
       if (id.startsWith("duo-workflow-")) {
-        const gitlab = yield* Effect.promise(() => import("gitlab-ai-provider")).pipe(Effect.orDie);
+        const gitlab = yield* Effect.promise(() => import("gitlab-ai-provider"));
         const workflowRef = typeof evt.model.settings?.workflowRef === "string" ? evt.model.settings.workflowRef : undefined;
         const workflowDefinition = typeof evt.model.settings?.workflowDefinition === "string" ? evt.model.settings.workflowDefinition : undefined;
         const language = evt.sdk.workflowChat(gitlab.isWorkflowModel(id) ? id : "duo-workflow", {

package/dist/chunks/project-j32vdj8r.js

@@ -0,0 +1,16 @@
+// src/plugin/provider/sdk-factory.ts
+import { Effect } from "effect";
+import { pathToFileURL } from "url";
+import { importModule } from "@opencode-ai/util/runtime-import";
+var loadSDKFactory = Effect.fnUntraced(function* (npm, packageName) {
+  const installedPath = packageName.startsWith("file://") ? packageName : (yield* npm.add(packageName).pipe(Effect.orDie)).entrypoint;
+  if (!installedPath)
+    return yield* Effect.die(new Error(`Package ${packageName} has no import entrypoint`));
+  const mod = yield* Effect.promise(() => importModule(installedPath.startsWith("file://") ? installedPath : pathToFileURL(installedPath).href));
+  const match = Object.keys(mod).find((name) => name.startsWith("create"));
+  if (!match)
+    return yield* Effect.die(new Error(`Package ${packageName} has no provider factory export`));
+  return mod[match];
+});
+
+export { loadSDKFactory };

package/dist/chunks/{tool-yncnzy6p.js → project-j5sjtdxs.js}

@@ -1,12 +1,12 @@
 import {
   exports_environment1 as exports_environment
-} from "./tool-3jshngxf.js";
+} from "./project-0xzcm754.js";
 import {
   exports_keyed_mutex
-} from "./tool-0kvmztkf.js";
+} from "./project-0kvmztkf.js";
 import {
   __export
-} from "./tool-rvfvac9x.js";
+} from "./project-rvfvac9x.js";
 
 // src/file-mutation.ts
 var exports_file_mutation = {};

package/dist/chunks/{tool-pqe0bsb2.js → project-jcsmb80n.js}

@@ -1,15 +1,15 @@
 import {
   exports_environment1 as exports_environment
-} from "./tool-3jshngxf.js";
+} from "./project-0xzcm754.js";
 import {
   __export
-} from "./tool-rvfvac9x.js";
+} from "./project-rvfvac9x.js";
 
 // src/mcp/stdio.ts
 var exports_stdio = {};
 __export(exports_stdio, {
   make: () => make,
-  MCPStdio: () => exports_stdio
+  McpStdio: () => exports_stdio
 });
 import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
 import { Cause, Duration, Effect, Queue, Scope, Stream } from "effect";

package/dist/chunks/{tool-n0eq3s1b.js → project-jj3fzgje.js}

@@ -1,18 +1,18 @@
 import {
   WorkspaceTable
-} from "./tool-61ek4hj9.js";
+} from "./project-61ek4hj9.js";
 import {
   exports_driver
-} from "./tool-t14kykx1.js";
+} from "./project-t14kykx1.js";
 import {
   exports_database
-} from "./tool-merfm3fd.js";
+} from "./project-gcc0jgqv.js";
 import {
   exports_keyed_mutex
-} from "./tool-0kvmztkf.js";
+} from "./project-0kvmztkf.js";
 import {
   __export
-} from "./tool-rvfvac9x.js";
+} from "./project-rvfvac9x.js";
 
 // src/workspace.ts
 var exports_workspace = {};

package/dist/chunks/project-k2bjf35z.js

@@ -0,0 +1,304 @@
+import {
+  iife
+} from "./project-ehj9csmv.js";
+import {
+  configuredSettings
+} from "./project-sdcydb11.js";
+import {
+  exports_integration
+} from "./project-pm64n062.js";
+import {
+  exports_app
+} from "./project-50jxp3hw.js";
+import {
+  exports_model
+} from "./project-r13w8t0w.js";
+import {
+  exports_credential
+} from "./project-qhe68xsc.js";
+import {
+  exports_provider
+} from "./project-krsqcmnj.js";
+import {
+  which
+} from "./project-k3e42drn.js";
+import {
+  exports_bus
+} from "./project-gy9zm4ck.js";
+import {
+  __require
+} from "./project-rvfvac9x.js";
+
+// src/plugin/provider/azure.ts
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { Clock, Effect, Schema, Semaphore, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Form } from "@opencode-ai/schema/form";
+import { AppProcess } from "@opencode-ai/util/process";
+var cognitiveScope = "https://cognitiveservices.azure.com/.default";
+var foundryScope = "https://ai.azure.com/.default";
+var methodID = exports_integration.MethodID.make("azure-cli");
+var decodeJSON = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
+var decodeProfile = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ subscriptions: Schema.Array(Schema.Unknown) })));
+var decodeToken = Schema.decodeUnknownEffect(Schema.Struct({
+  accessToken: Schema.NonEmptyString,
+  expires_on: Schema.optional(Schema.Number),
+  expiresOn: Schema.optional(Schema.NonEmptyString)
+}));
+var decodeAccounts = Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({ name: Schema.NonEmptyString, resourceGroup: Schema.NonEmptyString })));
+var Deployments = Schema.Array(Schema.Struct({
+  name: Schema.NonEmptyString,
+  properties: Schema.Struct({
+    model: Schema.Struct({ name: Schema.NonEmptyString }),
+    provisioningState: Schema.NonEmptyString
+  })
+}));
+var decodeDeployments = Schema.decodeUnknownEffect(Deployments);
+function selectLanguage(sdk, modelID, useChat) {
+  if (useChat && sdk.chat)
+    return sdk.chat(modelID);
+  if (sdk.responses)
+    return sdk.responses(modelID);
+  if (sdk.messages)
+    return sdk.messages(modelID);
+  if (sdk.chat)
+    return sdk.chat(modelID);
+  return sdk.languageModel(modelID);
+}
+var AzurePlugin = define({
+  id: "opencode.provider.azure",
+  effect: Effect.fn(function* (ctx) {
+    const configured = yield* configuredSettings(exports_provider.ID.azure);
+    const processes = yield* AppProcess.Service;
+    const bus = yield* exports_bus.Service;
+    const tokens = new Map;
+    const loading = Semaphore.makeUnsafe(1);
+    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 available = Boolean(which("az"));
+    const signedIn = available ? yield* Effect.tryPromise(() => readFile(join(process.env.AZURE_CONFIG_DIR ?? join(homedir(), ".azure"), "azureProfile.json"), "utf8")).pipe(Effect.flatMap((text) => decodeProfile(text.replace(/^\uFEFF/, ""))), Effect.map((profile) => profile.subscriptions.length > 0), Effect.orElseSucceed(() => false)) : false;
+    const accounts = !resolveResourceName(configured) && typeof configured?.baseURL !== "string" && !process.env.AZURE_RESOURCE_GROUP && signedIn ? yield* command(["cognitiveservices", "account", "list", "--output", "json", "--only-show-errors"]).pipe(Effect.flatMap(decodeAccounts), Effect.orElseSucceed(() => [])) : [];
+    const form = (select = false) => iife(() => {
+      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,
+          ...select && accounts.length > 0 ? {
+            options: accounts.map((account) => ({
+              value: account.name,
+              label: account.name,
+              description: account.resourceGroup
+            })),
+            custom: true
+          } : {}
+        }
+      ]);
+    });
+    yield* ctx.integration.transform((draft) => {
+      draft.method.update({
+        integrationID: exports_provider.ID.azure,
+        method: { type: "key", label: "API key", form: form() }
+      });
+      if (!available)
+        return;
+      draft.method.update({
+        integrationID: exports_provider.ID.azure,
+        method: {
+          id: methodID,
+          type: "oauth",
+          label: "Microsoft Entra ID (Azure CLI)",
+          form: form(true)
+        },
+        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 : resolveResourceName(configured);
+            if (!resourceName)
+              return yield* Effect.fail(new Error("Azure resource name is required"));
+            const current = yield* token(cognitiveScope);
+            loaded.resource = resourceName;
+            loaded.deployments = yield* discover(resourceName);
+            yield* ctx.catalog.reload();
+            return exports_credential.OAuth.make({
+              type: "oauth",
+              methodID,
+              access: current.access,
+              refresh: "azure-cli",
+              expires: current.expires,
+              metadata: { resourceName }
+            });
+          })
+        }),
+        refresh: (credential) => token(cognitiveScope).pipe(Effect.map((current) => exports_credential.OAuth.make({ ...credential, access: current.access, expires: current.expires })))
+      });
+    });
+    const discover = Effect.fn("AzurePlugin.discover")(function* (resource) {
+      return yield* Effect.gen(function* () {
+        const group = process.env.AZURE_RESOURCE_GROUP;
+        const account = group ? { name: resource, resourceGroup: group } : (accounts.length > 0 ? accounts : yield* command(["cognitiveservices", "account", "list", "--output", "json", "--only-show-errors"]).pipe(Effect.flatMap(decodeAccounts))).find((item) => item.name.toLowerCase() === resource.toLowerCase());
+        if (!account)
+          return yield* Effect.fail(new Error(`Azure resource "${resource}" was not found in the active subscription`));
+        return yield* command([
+          "cognitiveservices",
+          "account",
+          "deployment",
+          "list",
+          "--name",
+          account.name,
+          "--resource-group",
+          account.resourceGroup,
+          "--output",
+          "json",
+          "--only-show-errors"
+        ]).pipe(Effect.flatMap(decodeDeployments));
+      }).pipe(Effect.catch((error) => Effect.logWarning("Azure model discovery failed", {
+        resource,
+        error: error instanceof Error ? error.message : String(error)
+      }).pipe(Effect.as(undefined))));
+    });
+    const load = Effect.fn("AzurePlugin.load")(function* () {
+      const connection = yield* ctx.integration.connection.active(exports_provider.ID.azure);
+      const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
+        return;
+      })) : undefined;
+      if (credential?.type !== "oauth" || credential.methodID !== methodID) {
+        loaded.resource = undefined;
+        loaded.deployments = undefined;
+        return;
+      }
+      const resource = typeof credential.metadata?.resourceName === "string" ? credential.metadata.resourceName : undefined;
+      loaded.resource = resource;
+      loaded.deployments = resource ? yield* discover(resource) : undefined;
+    });
+    yield* load();
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (item.provider.id !== exports_provider.ID.azure && exports_provider.packageName(item.provider.package) !== "@ai-sdk/azure")
+          continue;
+        const resourceName = resolveResourceName(item.provider.settings, loaded.resource);
+        if (resourceName)
+          evt.provider.update(item.provider.id, (provider) => {
+            provider.settings = {
+              ...provider.settings,
+              resourceName,
+              ...typeof provider.settings?.baseURL === "string" ? { baseURL: expandResourceName(provider.settings.baseURL, resourceName) } : {}
+            };
+          });
+        if (item.provider.id === exports_provider.ID.azure && loaded.deployments) {
+          const existing = Array.from(item.models.values());
+          const found = new Map;
+          loaded.deployments.forEach((deployment) => {
+            if (deployment.properties.provisioningState !== "Succeeded")
+              return;
+            const model = existing.find((model2) => model2.id.toLowerCase() === deployment.properties.model.name.toLowerCase());
+            if (!model)
+              return;
+            const id = found.has(model.id) ? exports_model.ID.make(deployment.name) : model.id;
+            found.set(id, {
+              ...model,
+              id,
+              name: id === model.id ? model.name : `${model.name} (${deployment.name})`,
+              modelID: exports_model.ID.make(deployment.name)
+            });
+          });
+          for (const id of Array.from(item.models.keys())) {
+            if (!found.has(exports_model.ID.make(id)))
+              evt.model.remove(item.provider.id, id);
+          }
+          for (const [id, model] of found) {
+            evt.model.update(item.provider.id, id, (draft) => Object.assign(draft, structuredClone(model)));
+          }
+        }
+        for (const model of item.models.values()) {
+          evt.model.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 (responsesWebSocketCapable(item.provider, draft))
+              draft.capabilities.responsesWebsockets = true;
+          });
+        }
+      }
+    });
+    const reload = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
+    yield* bus.subscribe(exports_credential.Event.Switched).pipe(Stream.filter((event) => event.data.integrationID === exports_integration.ID.make("azure")), Stream.runForEach(reload), Effect.forkScoped({ startImmediately: true }));
+    yield* ctx.session.hook("http.request", (evt) => Effect.gen(function* () {
+      if (evt.model.providerID !== exports_provider.ID.azure)
+        return;
+      const connection = yield* ctx.integration.connection.active(exports_provider.ID.azure);
+      const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
+        return;
+      })) : undefined;
+      if (credential?.type !== "oauth" || credential.methodID !== methodID)
+        return;
+      const url = new URL(evt.request.url);
+      const scope = url.hostname.endsWith(".services.ai.azure.com") && !url.pathname.startsWith("/models") ? foundryScope : cognitiveScope;
+      const current = yield* token(scope).pipe(Effect.orDie);
+      evt.request.headers.delete("api-key");
+      evt.request.headers.delete("x-api-key");
+      evt.request.headers.set("authorization", `Bearer ${current.access}`);
+      evt.request.headers.set("user-agent", exports_app.useragent(ctx.app));
+    }), { providerID: exports_provider.ID.azure });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.package !== "@ai-sdk/azure")
+        return;
+      if (evt.model.providerID === exports_provider.ID.azure) {
+        if (!evt.options.resourceName && !evt.options.baseURL && (!exports_provider.isAISDK(evt.model.package) || typeof evt.model.settings?.baseURL !== "string")) {
+          throw new Error("Azure resource name is missing; set AZURE_RESOURCE_NAME or configure resourceName/baseURL");
+        }
+      }
+      const mod = yield* Effect.promise(() => import("@ai-sdk/azure"));
+      evt.sdk = mod.createAzure(evt.options);
+    }));
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== exports_provider.ID.azure)
+        return;
+      evt.language = selectLanguage(evt.sdk, evt.model.modelID ?? evt.model.id, Boolean(evt.options.useCompletionUrls));
+    }));
+  })
+});
+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 responsesWebSocketCapable(provider, model) {
+  if (exports_provider.packageName(model.package ?? provider.package) !== "@ai-sdk/azure")
+    return false;
+  const settings = exports_provider.mergeOverlay(provider.settings, model.settings);
+  if (settings?.useCompletionUrls === true || 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 { AzurePlugin };

package/dist/chunks/{tool-jy183kys.js → project-k3my2f3q.js}

@@ -1,19 +1,19 @@
 import {
   exports_model_resolver
-} from "./tool-pkezspgh.js";
+} from "./project-mczqbtr0.js";
 import {
   SessionSchema
-} from "./tool-bjwj8hwv.js";
+} from "./project-bjwj8hwv.js";
 import {
   ID,
   Ref
-} from "./tool-r13w8t0w.js";
+} from "./project-r13w8t0w.js";
 import {
   exports_provider
-} from "./tool-krsqcmnj.js";
+} from "./project-krsqcmnj.js";
 import {
   __export
-} from "./tool-rvfvac9x.js";
+} from "./project-rvfvac9x.js";
 
 // src/session/runner/model.ts
 var exports_model = {};

package/dist/chunks/{tool-kg1345f7.js → project-kg1345f7.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./tool-rvfvac9x.js";
+} from "./project-rvfvac9x.js";
 
 // src/filesystem/protected.ts
 var exports_protected = {};

package/dist/chunks/{tool-kp1t5rcy.js → project-kp1t5rcy.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./tool-rvfvac9x.js";
+} from "./project-rvfvac9x.js";
 
 // src/config/plugin/entry-observer.ts
 var exports_entry_observer = {};

package/dist/chunks/{tool-krsqcmnj.js → project-krsqcmnj.js}

@@ -1,7 +1,7 @@
 import {
   __export,
   __require
-} from "./tool-rvfvac9x.js";
+} from "./project-rvfvac9x.js";
 
 // src/provider.ts
 var exports_provider = {};

package/dist/chunks/{tool-kt491qp2.js → project-kt491qp2.js}

@@ -1,13 +1,13 @@
 import {
   AbsolutePath,
   RelativePath
-} from "./tool-j07kk359.js";
+} from "./project-j07kk359.js";
 import {
   exports_keyed_mutex
-} from "./tool-0kvmztkf.js";
+} from "./project-0kvmztkf.js";
 import {
   __export
-} from "./tool-rvfvac9x.js";
+} from "./project-rvfvac9x.js";
 
 // src/git.ts
 var exports_git = {};