@ai-sdk/harness-opencode 1.0.109 → 1.0.111

package/src/opencode-auth.ts

@@ -9,11 +9,21 @@ import {
   isHarnessAuthenticationEnvironment,
 } from '@ai-sdk/harness/utils';
 
+export const OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE =
+  'AI_SDK_OPENCODE_NATIVE_ACCESS_TOKEN';
+
 export const OPENCODE_CREDENTIAL_ENVIRONMENT_VARIABLES = [
   'AI_GATEWAY_API_KEY',
   'OPENAI_API_KEY',
   'ANTHROPIC_API_KEY',
   'ANTHROPIC_AUTH_TOKEN',
+  'XAI_API_KEY',
+  'GITHUB_TOKEN',
+  'GITHUB_COPILOT_TOKEN',
+  'POE_API_KEY',
+  'OPENCODE_API_KEY',
+  'GITLAB_TOKEN',
+  OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE,
 ] as const;
 
 export function createOpenCodeRequestTransformations({
@@ -102,12 +112,55 @@ export function createOpenCodeRequestTransformations({
 
       return transformations;
     }
+    case 'xai':
+      return createBearerTransformation({
+        environment,
+        sandboxEnvironment,
+        environmentVariableName: 'XAI_API_KEY',
+        matchUrl: environment.XAI_BASE_URL ?? 'https://api.x.ai/v1',
+      });
+    case 'github-copilot':
+      return createBearerTransformation({
+        environment,
+        sandboxEnvironment,
+        environmentVariableName:
+          environment.GITHUB_COPILOT_TOKEN != null
+            ? 'GITHUB_COPILOT_TOKEN'
+            : 'GITHUB_TOKEN',
+        matchUrl: 'https://api.githubcopilot.com',
+      });
+    case 'poe':
+      return createBearerTransformation({
+        environment,
+        sandboxEnvironment,
+        environmentVariableName: 'POE_API_KEY',
+        matchUrl: 'https://api.poe.com',
+      });
+    case 'opencode-go':
+      return createBearerTransformation({
+        environment,
+        sandboxEnvironment,
+        environmentVariableName: 'OPENCODE_API_KEY',
+        matchUrl: 'https://opencode.ai/zen/go/v1',
+      });
+    case 'gitlab':
+      return createBearerTransformation({
+        environment,
+        sandboxEnvironment,
+        environmentVariableName: 'GITLAB_TOKEN',
+        matchUrl: environment.GITLAB_INSTANCE_URL ?? 'https://gitlab.com',
+      });
   }
 }
 
 export type OpenCodeResolvedAuthenticationMode =
   | 'anthropic'
   | 'openai'
+  | 'xai'
+  | 'github-copilot'
+  | 'poe'
+  | 'opencode-go'
+  | 'gitlab'
   | 'ai-gateway';
 
 export type OpenCodeAuthenticationMode = HarnessV1Authentication<
@@ -120,13 +173,13 @@ export function resolveOpenCodeProvider({
 }: {
   model?: string;
   provider?: string;
-}): 'anthropic' | 'openai' {
-  if (provider === 'anthropic' || provider === 'openai') {
+}): Exclude<OpenCodeResolvedAuthenticationMode, 'ai-gateway'> {
+  if (isDirectProvider(provider)) {
     return provider;
   }
   if (model?.includes('/')) {
     const [modelProvider] = model.split('/');
-    if (modelProvider === 'anthropic' || modelProvider === 'openai') {
+    if (isDirectProvider(modelProvider)) {
       return modelProvider;
     }
   }
@@ -167,11 +220,14 @@ export function resolveOpenCodeEnv({
   const suppliedEnvironment = isHarnessAuthenticationEnvironment(auth);
   const authenticationEnvironment = suppliedEnvironment ? auth : processEnv;
   const selectedProvider = resolveOpenCodeProvider({ model, provider });
-  if (selectedProvider === 'openai' && auth === 'openai') {
-    return pickOpenAI({ processEnv: authenticationEnvironment });
-  }
-  if (selectedProvider === 'anthropic' && auth === 'anthropic') {
-    return pickAnthropic({ processEnv: authenticationEnvironment });
+  if (
+    (selectedProvider === 'openai' && auth === 'openai') ||
+    (selectedProvider === 'anthropic' && auth === 'anthropic')
+  ) {
+    return pickDirectProvider({
+      provider: selectedProvider,
+      processEnv: authenticationEnvironment,
+    });
   }
 
   const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({
@@ -180,9 +236,10 @@ export function resolveOpenCodeEnv({
   if (auth === 'ai-gateway' || gatewayAuthFromEnv.apiKey) {
     return pickGateway({ gatewayAuthFromEnv });
   }
-  return selectedProvider === 'openai'
-    ? pickOpenAI({ processEnv: authenticationEnvironment })
-    : pickAnthropic({ processEnv: authenticationEnvironment });
+  return pickDirectProvider({
+    provider: selectedProvider,
+    processEnv: authenticationEnvironment,
+  });
 }
 
 export function resolveOpenCodeAuthenticationMode({
@@ -249,6 +306,90 @@ function pickAnthropic({
   return env;
 }
 
+function pickDirectProvider({
+  provider,
+  processEnv,
+}: {
+  provider: Exclude<OpenCodeResolvedAuthenticationMode, 'ai-gateway'>;
+  processEnv: Record<string, string | undefined>;
+}): Record<string, string> {
+  if (provider === 'openai') return pickOpenAI({ processEnv });
+  if (provider === 'anthropic') return pickAnthropic({ processEnv });
+  const names =
+    provider === 'xai'
+      ? ['XAI_API_KEY', 'XAI_BASE_URL']
+      : provider === 'github-copilot'
+        ? ['GITHUB_COPILOT_TOKEN', 'GITHUB_TOKEN']
+        : provider === 'poe'
+          ? ['POE_API_KEY']
+          : provider === 'opencode-go'
+            ? ['OPENCODE_API_KEY']
+            : ['GITLAB_TOKEN', 'GITLAB_INSTANCE_URL'];
+  return Object.fromEntries(
+    names.flatMap(name =>
+      processEnv[name] == null ? [] : [[name, processEnv[name]!]],
+    ),
+  );
+}
+
+export function hasOpenCodeCredential({
+  environment,
+  authenticationMode,
+}: {
+  environment: Record<string, string>;
+  authenticationMode: OpenCodeResolvedAuthenticationMode;
+}): boolean {
+  if (authenticationMode === 'ai-gateway') {
+    return environment.AI_GATEWAY_API_KEY != null;
+  }
+  return Object.keys(environment).some(
+    name =>
+      name.endsWith('_API_KEY') ||
+      name.endsWith('_TOKEN') ||
+      name === 'ANTHROPIC_AUTH_TOKEN',
+  );
+}
+
+function createBearerTransformation({
+  environment,
+  sandboxEnvironment,
+  environmentVariableName,
+  matchUrl,
+}: {
+  environment: Readonly<Record<string, string>>;
+  sandboxEnvironment: Readonly<Record<string, string>>;
+  environmentVariableName: string;
+  matchUrl: string;
+}): HarnessV1RequestTransformation[] {
+  const credential = environment[environmentVariableName];
+  const sandboxCredential = sandboxEnvironment[environmentVariableName];
+  return credential == null || sandboxCredential == null
+    ? []
+    : [
+        createCredentialRequestTransformation({
+          matchUrl,
+          matchHeaders: {
+            Authorization: `Bearer ${sandboxCredential}`,
+          },
+          transformHeaders: { Authorization: `Bearer ${credential}` },
+        }),
+      ];
+}
+
+function isDirectProvider(
+  value: string | undefined,
+): value is Exclude<OpenCodeResolvedAuthenticationMode, 'ai-gateway'> {
+  return (
+    value === 'anthropic' ||
+    value === 'openai' ||
+    value === 'xai' ||
+    value === 'github-copilot' ||
+    value === 'poe' ||
+    value === 'opencode-go' ||
+    value === 'gitlab'
+  );
+}
+
 function pickGateway({
   gatewayAuthFromEnv,
 }: {

package/src/opencode-harness.ts

@@ -17,6 +17,7 @@ import {
   type HarnessV1PromptControl,
   type HarnessV1ResponseFormat,
   type HarnessV1PortEndpoint,
+  type HarnessV1RequestTransformation,
   type HarnessV1ResumeSessionState,
   type HarnessV1Session,
   type HarnessV1Skill,
@@ -59,10 +60,18 @@ import {
 import {
   createOpenCodeRequestTransformations,
   OPENCODE_CREDENTIAL_ENVIRONMENT_VARIABLES,
-  resolveOpenCodeAuthenticationMode,
-  resolveOpenCodeEnv,
+  OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE,
   type OpenCodeAuthenticationMode,
 } from './opencode-auth';
+import {
+  createOpenCodeGitLabSubscriptionConfig,
+  createOpenCodeGitLabSubscriptionRequestTransformations,
+  createOpenCodeSubscriptionAuthContent,
+  createOpenCodeSubscriptionRequestTransformations,
+  requestOpenCodeGitLabDirectAccess,
+  resolveOpenCodeAuthentication,
+  resolveOpenCodeGitLabSubscriptionModel,
+} from './opencode-subscription';
 import {
   outboundMessageSchema,
   type InboundMessage,
@@ -298,14 +307,17 @@ export function createOpenCode(
           ? resumeData.openCodeSessionId
           : undefined;
       const coords = resumeData?.bridge;
-      const authenticationMode = resolveOpenCodeAuthenticationMode({
-        auth: settings.auth,
-        provider: settings.provider,
-      });
-      const resolvedAuthEnvironment = resolveOpenCodeEnv({
+      const authentication = await resolveOpenCodeAuthentication({
         auth: settings.auth,
         provider: settings.provider,
       });
+      const authenticationMode = authentication.authenticationMode;
+      const resolvedAuthEnvironment = authentication.environment;
+      let resolvedOpenCodeConfig = settings.openCodeConfig;
+      let transformModel:
+        | ((model: string | undefined) => string | undefined)
+        | undefined;
+      let gitLabSubscriptionBrokered = false;
       let sandboxAuthEnvironment = resolvedAuthEnvironment;
       let sandboxCredentialEnvironment: Record<string, string> | undefined;
       let credentialsBrokered = false;
@@ -325,11 +337,58 @@ export function createOpenCode(
           ...resolvedAuthEnvironment,
           ...sandboxCredentialEnvironment,
         };
-        const requestTransformations = createOpenCodeRequestTransformations({
+        const transformationSources = {
           env: resolvedAuthEnvironment,
           sandboxEnv: sandboxAuthEnvironment,
           auth: authenticationMode,
-        });
+        };
+        const sandboxSubscriptionAccessToken =
+          sandboxAuthEnvironment[
+            OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE
+          ];
+        let requestTransformations: HarnessV1RequestTransformation[];
+        if (
+          authentication.subscription?.providerId === 'gitlab' &&
+          sandboxSubscriptionAccessToken != null
+        ) {
+          const directAccess = await requestOpenCodeGitLabDirectAccess({
+            accessToken: authentication.subscription.accessToken,
+            ...(authentication.subscription.enterpriseUrl == null
+              ? {}
+              : { instanceUrl: authentication.subscription.enterpriseUrl }),
+            ...(process.env.GITLAB_AI_GATEWAY_URL == null
+              ? {}
+              : { aiGatewayUrl: process.env.GITLAB_AI_GATEWAY_URL }),
+          });
+          requestTransformations =
+            createOpenCodeGitLabSubscriptionRequestTransformations({
+              directAccess,
+              sandboxAccessToken: sandboxSubscriptionAccessToken,
+            });
+          resolvedOpenCodeConfig = createOpenCodeGitLabSubscriptionConfig({
+            openCodeConfig: settings.openCodeConfig,
+            sandboxAccessToken: sandboxSubscriptionAccessToken,
+            aiGatewayUrl: directAccess.aiGatewayUrl,
+            ...(startOpts.headers == null
+              ? {}
+              : { headers: startOpts.headers }),
+          });
+          transformModel = model =>
+            resolveOpenCodeGitLabSubscriptionModel({
+              model,
+              provider: settings.provider,
+            });
+          gitLabSubscriptionBrokered = true;
+        } else {
+          requestTransformations =
+            authentication.subscription == null ||
+            sandboxSubscriptionAccessToken == null
+              ? createOpenCodeRequestTransformations(transformationSources)
+              : createOpenCodeSubscriptionRequestTransformations({
+                  authentication: authentication.subscription,
+                  sandboxAccessToken: sandboxSubscriptionAccessToken,
+                });
+        }
         if (requestTransformations.length > 0) {
           await sandboxSession.addRequestTransformations(
             requestTransformations,
@@ -398,7 +457,7 @@ export function createOpenCode(
             proc: undefined,
             provider: settings.provider,
             reasoningVariant: settings.reasoningVariant,
-            openCodeConfig: settings.openCodeConfig,
+            openCodeConfig: resolvedOpenCodeConfig,
             mcpServers: settings.mcpServers,
             headers: startOpts.headers,
             openCodeSessionId: resumeSessionId,
@@ -414,6 +473,7 @@ export function createOpenCode(
             builtinToolFiltering: startOpts.builtinToolFiltering,
             sandbox: toolSafeSandboxSession,
             sandboxHomeDir,
+            transformModel,
             supportsUserMessageResponses: () => supportsUserMessageResponses,
           });
         } catch {}
@@ -458,8 +518,28 @@ export function createOpenCode(
             OPENCODE_CREDENTIAL_ENVIRONMENT_VARIABLES,
         });
       }
+      const subscriptionAccessToken =
+        forwardedAuthEnvironment[
+          OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE
+        ];
+      const forwardableAuthEnvironment = Object.fromEntries(
+        Object.entries(forwardedAuthEnvironment).filter(
+          ([name]) =>
+            name !== OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE,
+        ),
+      );
       const env = {
-        ...forwardedAuthEnvironment,
+        ...forwardableAuthEnvironment,
+        ...(gitLabSubscriptionBrokered ||
+        authentication.subscription == null ||
+        subscriptionAccessToken == null
+          ? {}
+          : {
+              OPENCODE_AUTH_CONTENT: createOpenCodeSubscriptionAuthContent({
+                authentication: authentication.subscription,
+                accessToken: subscriptionAccessToken,
+              }),
+            }),
         AI_SDK_HARNESS_CLIENT_APP: OPENCODE_CLIENT_APP,
         BRIDGE_CHANNEL_TOKEN: token,
         BRIDGE_WS_PORT: String(port),
@@ -555,7 +635,7 @@ export function createOpenCode(
         proc,
         provider: settings.provider,
         reasoningVariant: settings.reasoningVariant,
-        openCodeConfig: settings.openCodeConfig,
+        openCodeConfig: resolvedOpenCodeConfig,
         mcpServers: settings.mcpServers,
         headers: startOpts.headers,
         openCodeSessionId: resumeSessionId,
@@ -571,6 +651,7 @@ export function createOpenCode(
         builtinToolFiltering: startOpts.builtinToolFiltering,
         sandbox: toolSafeSandboxSession,
         sandboxHomeDir,
+        transformModel,
         supportsUserMessageResponses: () => supportsUserMessageResponses,
       });
     },
@@ -764,6 +845,7 @@ function createSession({
   builtinToolFiltering,
   sandbox,
   sandboxHomeDir,
+  transformModel,
   supportsUserMessageResponses,
 }: {
   sessionId: string;
@@ -787,6 +869,9 @@ function createSession({
   builtinToolFiltering: HarnessV1BuiltinToolFiltering | undefined;
   sandbox: SandboxSession;
   sandboxHomeDir: string;
+  transformModel:
+    | ((model: string | undefined) => string | undefined)
+    | undefined;
   supportsUserMessageResponses: () => boolean;
 }): HarnessV1Session {
   let stopped = false;
@@ -950,7 +1035,7 @@ function createSession({
   };
 
   const startBase = (turnModel: string | undefined) => ({
-    model: turnModel,
+    model: transformModel == null ? turnModel : transformModel(turnModel),
     provider,
     ...(reasoningVariant ? { variant: reasoningVariant } : {}),
     ...(openCodeConfig == null ? {} : { openCodeConfig }),
@@ -1075,7 +1160,10 @@ function createSession({
       }
       await runCompactOperation({
         channel,
-        model: selectedModel,
+        model:
+          transformModel == null
+            ? selectedModel
+            : transformModel(selectedModel),
         provider,
         permissionMode,
         debug,