@ai-sdk/harness-opencode 0.0.0-d3900c59-20260626174016

package/src/index.ts

@@ -0,0 +1,11 @@
+import { createOpenCode } from './opencode-harness';
+
+/**
+ * Default `openCode` harness instance with no overrides. Equivalent to
+ * `createOpenCode()`.
+ */
+export const openCode = createOpenCode();
+
+export { createOpenCode } from './opencode-harness';
+export type { OpenCodeHarnessSettings } from './opencode-harness';
+export type { OpenCodeAuthOptions } from './opencode-auth';

package/src/opencode-auth.ts

@@ -0,0 +1,175 @@
+import { getAiGatewayAuthFromEnv } from '@ai-sdk/harness/utils';
+
+export type OpenCodeAuthOptions = {
+  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 function resolveOpenCodeProvider({
+  model,
+  provider,
+}: {
+  model?: string;
+  provider?: string;
+}): 'anthropic' | 'openai' {
+  if (provider === 'anthropic' || provider === 'openai') {
+    return provider;
+  }
+  if (model?.includes('/')) {
+    const [modelProvider] = model.split('/');
+    if (modelProvider === 'anthropic' || modelProvider === 'openai') {
+      return modelProvider;
+    }
+  }
+  return 'anthropic';
+}
+
+export function splitOpenCodeModel(
+  model: string | undefined,
+  provider: string | undefined,
+): { providerID?: string; modelID?: string; model?: string } {
+  if (!model) return {};
+  if (model.includes('/')) {
+    const [providerID, ...rest] = model.split('/');
+    return {
+      providerID,
+      modelID: rest.join('/'),
+      model,
+    };
+  }
+  return {
+    providerID: provider,
+    modelID: model,
+    model: provider ? `${provider}/${model}` : model,
+  };
+}
+
+export function resolveOpenCodeEnv({
+  auth,
+  model,
+  provider,
+  processEnv = process.env,
+}: {
+  auth: OpenCodeAuthOptions | undefined;
+  model?: string;
+  provider?: string;
+  processEnv?: Record<string, string | undefined>;
+}): Record<string, string> {
+  const selectedProvider = resolveOpenCodeProvider({ model, provider });
+  if (auth?.openaiCompatible) {
+    return pickOpenAICompatible(auth.openaiCompatible, processEnv);
+  }
+  if (selectedProvider === 'openai') {
+    if (auth?.openai) {
+      return pickOpenAI({ explicit: auth.openai, processEnv });
+    }
+  } else if (auth?.anthropic) {
+    return pickAnthropic({ explicit: auth.anthropic, processEnv });
+  }
+
+  const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({ env: processEnv });
+  if (auth?.gateway) {
+    return pickGateway({ explicit: auth.gateway, gatewayAuthFromEnv });
+  }
+  if (gatewayAuthFromEnv.apiKey) {
+    return pickGateway({ explicit: {}, gatewayAuthFromEnv });
+  }
+  return selectedProvider === 'openai'
+    ? pickOpenAI({ processEnv })
+    : pickAnthropic({ processEnv });
+}
+
+function pickOpenAICompatible(
+  explicit: NonNullable<OpenCodeAuthOptions['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<OpenCodeAuthOptions['openai']>;
+  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 organization = explicit?.organization ?? processEnv.OPENAI_ORGANIZATION;
+  if (organization) env.OPENAI_ORGANIZATION = organization;
+  const project = explicit?.project ?? processEnv.OPENAI_PROJECT;
+  if (project) env.OPENAI_PROJECT = project;
+  return env;
+}
+
+function pickAnthropic({
+  explicit,
+  processEnv,
+}: {
+  explicit?: NonNullable<OpenCodeAuthOptions['anthropic']>;
+  processEnv: Record<string, string | undefined>;
+}): Record<string, string> {
+  const env: Record<string, string> = {};
+  const apiKey = explicit?.apiKey ?? processEnv.ANTHROPIC_API_KEY;
+  if (apiKey) env.ANTHROPIC_API_KEY = apiKey;
+  const authToken = explicit?.authToken ?? processEnv.ANTHROPIC_AUTH_TOKEN;
+  if (authToken) env.ANTHROPIC_AUTH_TOKEN = authToken;
+  const baseUrl = explicit?.baseUrl ?? processEnv.ANTHROPIC_BASE_URL;
+  if (baseUrl) env.ANTHROPIC_BASE_URL = baseUrl;
+  return env;
+}
+
+function pickGateway({
+  explicit,
+  gatewayAuthFromEnv,
+}: {
+  explicit: NonNullable<OpenCodeAuthOptions['gateway']>;
+  gatewayAuthFromEnv: ReturnType<typeof getAiGatewayAuthFromEnv>;
+}): Record<string, string> {
+  const env: Record<string, string> = {};
+  const apiKey = explicit.apiKey ?? gatewayAuthFromEnv.apiKey;
+  if (apiKey) env.AI_GATEWAY_API_KEY = apiKey;
+  env.AI_GATEWAY_BASE_URL = toOpenCodeGatewayBaseUrl(
+    explicit.baseUrl ?? gatewayAuthFromEnv.baseUrl,
+  );
+  return env;
+}
+
+export function toOpenCodeGatewayBaseUrl(baseUrl: string): string {
+  const trimmed = baseUrl.replace(/\/+$/, '');
+  return trimmed.endsWith('/v1') ? trimmed : `${trimmed}/v1`;
+}

package/src/opencode-bridge-protocol.ts

@@ -0,0 +1,29 @@
+import {
+  harnessV1BridgeInboundCommandSchemas,
+  harnessV1BridgeOutboundMessageSchema,
+  harnessV1BridgeReadySchema,
+  harnessV1BridgeStartBaseSchema,
+} from '@ai-sdk/harness';
+import { z } from 'zod/v4';
+
+export const outboundMessageSchema = harnessV1BridgeOutboundMessageSchema;
+export type OutboundMessage = z.infer<typeof outboundMessageSchema>;
+
+export const startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
+  operation: z.enum(['prompt', 'compact']).optional(),
+  provider: z.string().optional(),
+  variant: z.string().optional(),
+  instructions: z.string().optional(),
+  resumeSessionId: z.string().optional(),
+});
+
+export type StartMessage = z.infer<typeof startMessageSchema>;
+
+export const inboundMessageSchema = z.discriminatedUnion('type', [
+  startMessageSchema,
+  ...harnessV1BridgeInboundCommandSchemas,
+]);
+export type InboundMessage = z.infer<typeof inboundMessageSchema>;
+
+export const bridgeReadySchema = harnessV1BridgeReadySchema;
+export type BridgeReady = z.infer<typeof bridgeReadySchema>;