@ai-sdk/harness-opencode 1.0.92 → 1.0.94

package/src/opencode-auth.ts

@@ -1,10 +1,12 @@
 import type {
+  HarnessV1Authentication,
   HarnessV1RequestTransformation,
   HarnessV1RequestTransformationSources,
 } from '@ai-sdk/harness';
 import {
   createCredentialRequestTransformation,
   getAiGatewayAuthFromEnv,
+  isHarnessAuthenticationEnvironment,
 } from '@ai-sdk/harness/utils';
 
 export const OPENCODE_CREDENTIAL_ENVIRONMENT_VARIABLES = [
@@ -108,40 +110,9 @@ export type OpenCodeResolvedAuthenticationMode =
   | 'openai'
   | 'ai-gateway';
 
-export 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.
- */
-export 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>;
-  };
-};
-
-export type OpenCodeAuthOptions =
-  | OpenCodeAuthenticationMode
-  | LegacyOpenCodeAuthOptions;
+export type OpenCodeAuthenticationMode = HarnessV1Authentication<
+  'anthropic' | 'openai'
+>;
 
 export function resolveOpenCodeProvider({
   model,
@@ -188,37 +159,30 @@ export function resolveOpenCodeEnv({
   provider,
   processEnv = process.env,
 }: {
-  auth: OpenCodeAuthOptions | undefined;
+  auth: OpenCodeAuthenticationMode | undefined;
   model?: string;
   provider?: string;
   processEnv?: Record<string, string | undefined>;
 }): Record<string, string> {
-  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 });
+  if (selectedProvider === 'anthropic' && auth === 'anthropic') {
+    return pickAnthropic({ processEnv: authenticationEnvironment });
   }
 
-  const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({ env: processEnv });
-  if (normalizedAuth?.gateway) {
-    return pickGateway({
-      explicit: normalizedAuth.gateway,
-      gatewayAuthFromEnv,
-    });
-  }
-  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 });
+    ? pickOpenAI({ processEnv: authenticationEnvironment })
+    : pickAnthropic({ processEnv: authenticationEnvironment });
 }
 
 export function resolveOpenCodeAuthenticationMode({
@@ -227,29 +191,24 @@ export function resolveOpenCodeAuthenticationMode({
   provider,
   processEnv = process.env,
 }: {
-  auth: OpenCodeAuthOptions | undefined;
+  auth: OpenCodeAuthenticationMode | undefined;
   model?: string;
   provider?: string;
   processEnv?: Record<string, string | undefined>;
 }): OpenCodeResolvedAuthenticationMode {
-  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) {
@@ -258,99 +217,47 @@ export function resolveOpenCodeAuthenticationMode({
   return selectedProvider;
 }
 
-function normalizeOpenCodeAuthToLegacyAuth(
-  auth: OpenCodeAuthOptions | undefined,
-): LegacyOpenCodeAuthOptions | undefined {
-  if (auth == null || auth === 'auto') {
-    return undefined;
-  }
-  if (typeof auth === 'string') {
-    switch (auth) {
-      case 'anthropic':
-        return { anthropic: {} };
-      case 'openai':
-        return { openai: {} };
-      case 'ai-gateway':
-        return { gateway: {} };
-      default:
-        return undefined;
-    }
-  }
-
-  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: NonNullable<LegacyOpenCodeAuthOptions['openaiCompatible']>,
-  processEnv: Record<string, string | undefined>,
-): Record<string, string> {
-  const env: Record<string, string> = {};
-  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,
 }: {
-  explicit?: NonNullable<LegacyOpenCodeAuthOptions['openai']>;
   processEnv: Record<string, string | undefined>;
 }): Record<string, string> {
   const env: Record<string, string> = {};
-  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,
 }: {
-  explicit?: NonNullable<LegacyOpenCodeAuthOptions['anthropic']>;
   processEnv: Record<string, string | undefined>;
 }): Record<string, string> {
   const env: Record<string, string> = {};
-  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,
 }: {
-  explicit: NonNullable<LegacyOpenCodeAuthOptions['gateway']>;
   gatewayAuthFromEnv: ReturnType<typeof getAiGatewayAuthFromEnv>;
 }): Record<string, string> {
   const env: Record<string, string> = {};
-  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;
 }

package/src/opencode-harness.ts

@@ -57,7 +57,7 @@ import {
   resolveOpenCodeAuthenticationMode,
   resolveOpenCodeEnv,
   splitOpenCodeModel,
-  type OpenCodeAuthOptions,
+  type OpenCodeAuthenticationMode,
 } from './opencode-auth';
 import {
   outboundMessageSchema,
@@ -79,7 +79,7 @@ type WriteSkillsResult = {
 const OPENCODE_CLIENT_APP = `ai-sdk/harness-opencode/${VERSION}`;
 
 export 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