@ai-sdk/harness-opencode 1.0.92 → 1.0.94

package/dist/index.d.ts

@@ -1,39 +1,11 @@
 import * as _ai_sdk_provider_utils from '@ai-sdk/provider-utils';
 import * as _ai_sdk_harness from '@ai-sdk/harness';
-import { HarnessV1CredentialForwarding, HarnessV1PortEndpoint, HarnessV1, HarnessV1BuiltinTool } from '@ai-sdk/harness';
+import { HarnessV1Authentication, HarnessV1CredentialForwarding, HarnessV1PortEndpoint, HarnessV1, HarnessV1BuiltinTool } from '@ai-sdk/harness';
 
-type OpenCodeResolvedAuthenticationMode = 'anthropic' | 'openai' | 'ai-gateway';
-type OpenCodeAuthenticationMode = OpenCodeResolvedAuthenticationMode | 'auto';
-/**
- * @deprecated Passing an object to auth options is deprecated. Use an `OpenCodeAuthenticationMode` string value ("auto" | "anthropic" | "openai" | "ai-gateway") instead, and pass credentials via environment variables.
- */
-type LegacyOpenCodeAuthOptions = {
-    readonly gateway?: {
-        readonly apiKey?: string;
-        readonly baseUrl?: string;
-    };
-    readonly anthropic?: {
-        readonly apiKey?: string;
-        readonly authToken?: string;
-        readonly baseUrl?: string;
-    };
-    readonly openai?: {
-        readonly apiKey?: string;
-        readonly baseUrl?: string;
-        readonly organization?: string;
-        readonly project?: string;
-    };
-    readonly openaiCompatible?: {
-        readonly apiKey?: string;
-        readonly baseUrl?: string;
-        readonly name?: string;
-        readonly queryParams?: Record<string, string>;
-    };
-};
-type OpenCodeAuthOptions = OpenCodeAuthenticationMode | LegacyOpenCodeAuthOptions;
+type OpenCodeAuthenticationMode = HarnessV1Authentication<'anthropic' | 'openai'>;
 
 type OpenCodeHarnessSettings = {
-    readonly auth?: OpenCodeAuthOptions;
+    readonly auth?: OpenCodeAuthenticationMode;
     /**
      * Customizes each credential value before it is forwarded into a sandbox
      * process. This does not restrict which credentials the harness adapter can
@@ -201,4 +173,4 @@ declare const openCode: _ai_sdk_harness.HarnessV1<{
     }, any, any>;
 }>;
 
-export { type OpenCodeAuthOptions, type OpenCodeAuthenticationMode, type OpenCodeHarnessSettings, VERSION, createOpenCode, openCode };
+export { type OpenCodeAuthenticationMode, type OpenCodeHarnessSettings, VERSION, createOpenCode, openCode };

package/dist/index.js

@@ -94,7 +94,8 @@ async function readBridgeAsset(name) {
 // src/opencode-auth.ts
 import {
   createCredentialRequestTransformation,
-  getAiGatewayAuthFromEnv
+  getAiGatewayAuthFromEnv,
+  isHarnessAuthenticationEnvironment
 } from "@ai-sdk/harness/utils";
 var OPENCODE_CREDENTIAL_ENVIRONMENT_VARIABLES = [
   "AI_GATEWAY_API_KEY",
@@ -211,29 +212,22 @@ function resolveOpenCodeEnv({
   provider,
   processEnv = process.env
 }) {
-  const normalizedAuth = normalizeOpenCodeAuthToLegacyAuth(auth);
+  const suppliedEnvironment = isHarnessAuthenticationEnvironment(auth);
+  const authenticationEnvironment = suppliedEnvironment ? auth : processEnv;
   const selectedProvider = resolveOpenCodeProvider({ model, provider });
-  if (normalizedAuth?.openaiCompatible) {
-    return pickOpenAICompatible(normalizedAuth.openaiCompatible, processEnv);
+  if (selectedProvider === "openai" && auth === "openai") {
+    return pickOpenAI({ processEnv: authenticationEnvironment });
   }
-  if (selectedProvider === "openai") {
-    if (normalizedAuth?.openai) {
-      return pickOpenAI({ explicit: normalizedAuth.openai, processEnv });
-    }
-  } else if (normalizedAuth?.anthropic) {
-    return pickAnthropic({ explicit: normalizedAuth.anthropic, processEnv });
-  }
-  const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({ env: processEnv });
-  if (normalizedAuth?.gateway) {
-    return pickGateway({
-      explicit: normalizedAuth.gateway,
-      gatewayAuthFromEnv
-    });
+  if (selectedProvider === "anthropic" && auth === "anthropic") {
+    return pickAnthropic({ processEnv: authenticationEnvironment });
   }
-  if (gatewayAuthFromEnv.apiKey) {
-    return pickGateway({ explicit: {}, gatewayAuthFromEnv });
+  const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({
+    env: authenticationEnvironment
+  });
+  if (auth === "ai-gateway" || gatewayAuthFromEnv.apiKey) {
+    return pickGateway({ gatewayAuthFromEnv });
   }
-  return selectedProvider === "openai" ? pickOpenAI({ processEnv }) : pickAnthropic({ processEnv });
+  return selectedProvider === "openai" ? pickOpenAI({ processEnv: authenticationEnvironment }) : pickAnthropic({ processEnv: authenticationEnvironment });
 }
 function resolveOpenCodeAuthenticationMode({
   auth,
@@ -241,17 +235,17 @@ function resolveOpenCodeAuthenticationMode({
   provider,
   processEnv = process.env
 }) {
-  if (typeof auth !== "string" && auth?.openaiCompatible) {
-    return "openai";
+  if (isHarnessAuthenticationEnvironment(auth)) {
+    return getAiGatewayAuthFromEnv({ env: auth }).apiKey ? "ai-gateway" : resolveOpenCodeProvider({ model, provider });
   }
   const selectedProvider = resolveOpenCodeProvider({ model, provider });
-  if (selectedProvider === "openai" && (auth === "openai" || typeof auth !== "string" && auth?.openai)) {
+  if (selectedProvider === "openai" && auth === "openai") {
     return "openai";
   }
-  if (selectedProvider === "anthropic" && (auth === "anthropic" || typeof auth !== "string" && auth?.anthropic)) {
+  if (selectedProvider === "anthropic" && auth === "anthropic") {
     return "anthropic";
   }
-  if (auth === "ai-gateway" || typeof auth !== "string" && auth?.gateway) {
+  if (auth === "ai-gateway") {
     return "ai-gateway";
   }
   if (getAiGatewayAuthFromEnv({ env: processEnv }).apiKey) {
@@ -259,80 +253,39 @@ function resolveOpenCodeAuthenticationMode({
   }
   return selectedProvider;
 }
-function normalizeOpenCodeAuthToLegacyAuth(auth) {
-  if (auth == null || auth === "auto") {
-    return void 0;
-  }
-  if (typeof auth === "string") {
-    switch (auth) {
-      case "anthropic":
-        return { anthropic: {} };
-      case "openai":
-        return { openai: {} };
-      case "ai-gateway":
-        return { gateway: {} };
-      default:
-        return void 0;
-    }
-  }
-  console.warn(
-    '[opencode] Passing an object to auth options is deprecated. Use a string mode ("auto" | "anthropic" | "openai" | "ai-gateway") instead, and pass credentials via environment variables.'
-  );
-  return auth;
-}
-function pickOpenAICompatible(explicit, processEnv) {
-  const env = {};
-  const apiKey = explicit.apiKey ?? processEnv.OPENAI_API_KEY;
-  if (apiKey) env.OPENAI_API_KEY = apiKey;
-  const baseUrl = explicit.baseUrl ?? processEnv.OPENAI_BASE_URL;
-  if (baseUrl) env.OPENAI_BASE_URL = baseUrl;
-  const name = explicit.name ?? processEnv.OPENAI_NAME;
-  if (name) env.OPENAI_NAME = name;
-  if (explicit.queryParams && Object.keys(explicit.queryParams).length > 0) {
-    env.OPENAI_QUERY_PARAMS_JSON = JSON.stringify(explicit.queryParams);
-  } else if (processEnv.OPENAI_QUERY_PARAMS_JSON) {
-    env.OPENAI_QUERY_PARAMS_JSON = processEnv.OPENAI_QUERY_PARAMS_JSON;
-  }
-  return env;
-}
 function pickOpenAI({
-  explicit,
   processEnv
 }) {
   const env = {};
-  const apiKey = explicit?.apiKey ?? processEnv.OPENAI_API_KEY;
+  const apiKey = processEnv.OPENAI_API_KEY;
   if (apiKey) env.OPENAI_API_KEY = apiKey;
-  const baseUrl = explicit?.baseUrl ?? processEnv.OPENAI_BASE_URL;
+  const baseUrl = processEnv.OPENAI_BASE_URL;
   if (baseUrl) env.OPENAI_BASE_URL = baseUrl;
-  const organization = explicit?.organization ?? processEnv.OPENAI_ORGANIZATION;
+  const organization = processEnv.OPENAI_ORGANIZATION;
   if (organization) env.OPENAI_ORGANIZATION = organization;
-  const project = explicit?.project ?? processEnv.OPENAI_PROJECT;
+  const project = processEnv.OPENAI_PROJECT;
   if (project) env.OPENAI_PROJECT = project;
   return env;
 }
 function pickAnthropic({
-  explicit,
   processEnv
 }) {
   const env = {};
-  const apiKey = explicit?.apiKey ?? processEnv.ANTHROPIC_API_KEY;
+  const apiKey = processEnv.ANTHROPIC_API_KEY;
   if (apiKey) env.ANTHROPIC_API_KEY = apiKey;
-  const authToken = explicit?.authToken ?? processEnv.ANTHROPIC_AUTH_TOKEN;
+  const authToken = processEnv.ANTHROPIC_AUTH_TOKEN;
   if (authToken) env.ANTHROPIC_AUTH_TOKEN = authToken;
-  const baseUrl = explicit?.baseUrl ?? processEnv.ANTHROPIC_BASE_URL;
+  const baseUrl = processEnv.ANTHROPIC_BASE_URL;
   if (baseUrl) env.ANTHROPIC_BASE_URL = baseUrl;
   return env;
 }
 function pickGateway({
-  explicit,
   gatewayAuthFromEnv
 }) {
   const env = {};
-  const apiKey = explicit.apiKey ?? gatewayAuthFromEnv.apiKey;
+  const apiKey = gatewayAuthFromEnv.apiKey;
   if (apiKey) env.AI_GATEWAY_API_KEY = apiKey;
-  const baseUrl = toOpenCodeGatewayBaseUrl(
-    explicit.baseUrl ?? gatewayAuthFromEnv.baseUrl
-  );
+  const baseUrl = toOpenCodeGatewayBaseUrl(gatewayAuthFromEnv.baseUrl);
   env.AI_GATEWAY_BASE_URL = baseUrl;
   return env;
 }
@@ -364,7 +317,7 @@ var inboundMessageSchema = z.discriminatedUnion("type", [
 ]);
 
 // src/version.ts
-var VERSION = true ? "1.0.92" : "0.0.0-test";
+var VERSION = true ? "1.0.94" : "0.0.0-test";
 
 // src/opencode-harness.ts
 var OPENCODE_CLIENT_APP = `ai-sdk/harness-opencode/${VERSION}`;