@mengruo/dsh-vision-toolkit 0.1.4 → 0.1.5

package/src/config.ts

@@ -77,6 +77,10 @@ export interface VisionProviderConfig {
   anthropicThinking?: 'omit' | 'disabled' | 'adaptive'
   /** Outbound User-Agent for provider requests and connection tests. */
   userAgent?: string
+  /** Whether to request a streamed (SSE) completion instead of one JSON response (default false). */
+  stream?: boolean
+  /** Whether to upload images to object storage and send the model a URL instead of base64 (default false). */
+  uploadViaUrl?: boolean
   /** t1: per-request hedge threshold in seconds. A single request exceeding t1 keeps running while the next provider starts in parallel. */
   t1Seconds?: number
   /** t2: per-provider cumulative cutoff in seconds. Total accumulated request time reaching t2 terminates the provider. */
@@ -106,6 +110,10 @@ export interface VisionToolkitConfig {
     anthropicThinking?: 'omit' | 'disabled' | 'adaptive'
     /** Outbound User-Agent for provider requests and connection tests. */
     userAgent?: string
+    /** Whether to request a streamed (SSE) completion instead of one JSON response (default false). */
+    stream?: boolean
+    /** Whether to upload images to object storage and send the model a URL instead of base64 (default false). */
+    uploadViaUrl?: boolean
   }
   /** Ordered online vision providers; array order is the failover priority. */
   providers?: VisionProviderConfig[]
@@ -123,6 +131,21 @@ export interface VisionToolkitConfig {
   maxImagePixels?: number
   /** Default per-model in-flight request cap inherited by providers that do not set their own. */
   concurrency?: number
+  /**
+   * Optional S3-compatible object storage used by the URL image-transfer path.
+   * `endpoint`, `bucket`, and `credential` are required to enable URL transfer;
+   * `publicBase` is optional and falls back to presigned URLs when unset.
+   */
+  objectStorage?: {
+    /** S3-compatible API endpoint (e.g. R2, MinIO, Tencent COS). */
+    endpoint?: string
+    /** Bucket name. */
+    bucket?: string
+    /** DSH Credential reference holding "accessKeyId:secretAccessKey". */
+    credential?: string
+    /** Public base URL (custom domain / r2.dev); when unset, presigned URLs are used. */
+    publicBase?: string
+  }
   runtime?: {
     /** `managed` uses the packaged snapshot and isolated venv; `external` uses a clean pinned checkout. */
     mode?: 'managed' | 'external'
@@ -182,6 +205,7 @@ export const Config: Schema<VisionToolkitConfig> = z.object({
     protocol: z.union(['openai', 'anthropic'] as const).default('openai'),
     anthropicThinking: z.union(['omit', 'disabled', 'adaptive'] as const).default('omit'),
     userAgent: z.string().default(DEFAULT_VISION_USER_AGENT),
+    stream: z.boolean().default(false),
   }),
   providers: z.array(z.object({
     name: z.string(),
@@ -193,6 +217,8 @@ export const Config: Schema<VisionToolkitConfig> = z.object({
     protocol: z.union(['openai', 'anthropic'] as const).default('openai'),
     anthropicThinking: z.union(['omit', 'disabled', 'adaptive'] as const).default('omit'),
     userAgent: z.string(),
+    stream: z.boolean().default(false),
+    uploadViaUrl: z.boolean().default(false),
     t1Seconds: z.number(),
     t2Seconds: z.number(),
     maxImageBytes: z.number(),
@@ -207,6 +233,12 @@ export const Config: Schema<VisionToolkitConfig> = z.object({
   maxImageBytes: z.number().default(4194304),
   maxImagePixels: z.number().default(20000000),
   concurrency: z.number().default(4),
+  objectStorage: z.object({
+    endpoint: z.string().default(''),
+    bucket: z.string().default(''),
+    credential: z.string().default(''),
+    publicBase: z.string().default(''),
+  }),
   runtime: z.object({
     mode: z.union(['managed', 'external'] as const).default('managed'),
     agentVisionToolkitPath: z.string(),
@@ -235,6 +267,8 @@ export interface ResolvedProvider {
   protocol: 'openai' | 'anthropic'
   anthropicThinking: 'omit' | 'disabled' | 'adaptive'
   userAgent: string
+  stream: boolean
+  uploadViaUrl: boolean
   t1Seconds: number
   t2Seconds: number
   maxImageBytes: number
@@ -252,6 +286,8 @@ export interface ResolvedVisionToolkitConfig {
     protocol: 'openai' | 'anthropic'
     anthropicThinking: 'omit' | 'disabled' | 'adaptive'
     userAgent: string
+    stream: boolean
+    uploadViaUrl: boolean
   }
   /** Ordered failover pool; array order is the priority, highest first. */
   providers: ResolvedProvider[]
@@ -262,6 +298,12 @@ export interface ResolvedVisionToolkitConfig {
   maxImageBytes: number
   maxImagePixels: number
   concurrency: number
+  objectStorage: {
+    endpoint: string
+    bucket: string
+    credential?: CredentialRef
+    publicBase?: string
+  }
   runtime: {
     mode: 'managed' | 'external'
     agentVisionToolkitPath?: string
@@ -366,6 +408,8 @@ function resolveProvider(
   if (userAgent.length === 0) {
     throw new VisionToolkitError('config', `${label}.userAgent must not be empty`)
   }
+  const stream = input.stream === true
+  const uploadViaUrl = input.uploadViaUrl === true
   const t1Seconds = input.t1Seconds ?? 90
   if (!Number.isInteger(t1Seconds) || t1Seconds < 1 || t1Seconds > MAX_TIMEOUT_SECONDS) {
     throw new VisionToolkitError('config', `${label}.t1Seconds must be an integer between 1 and ${MAX_TIMEOUT_SECONDS}`)
@@ -402,6 +446,8 @@ function resolveProvider(
     protocol,
     anthropicThinking,
     userAgent,
+    stream,
+    uploadViaUrl,
     t1Seconds,
     t2Seconds,
     maxImageBytes,
@@ -472,6 +518,19 @@ export function resolveConfig(config: VisionToolkitConfig = {}): ResolvedVisionT
     .map(dir => dir.trim())
     .filter(dir => dir.length > 0 && dir !== storageDir))]
   const allowedDirs = (config.allowedDirs ?? []).map(dir => dir.trim()).filter(dir => dir.length > 0)
+  const objectStorageInput = config.objectStorage ?? {}
+  const objectStorageEndpoint = objectStorageInput.endpoint?.trim() ?? ''
+  const objectStorageBucket = objectStorageInput.bucket?.trim() ?? ''
+  const objectStoragePublicBase = objectStorageInput.publicBase?.trim()
+  let objectStorageCredential: CredentialRef | undefined
+  const objectStorageCredentialSource = objectStorageInput.credential?.trim()
+  if (objectStorageCredentialSource !== undefined && objectStorageCredentialSource.length > 0) {
+    try {
+      objectStorageCredential = credentialRef(objectStorageCredentialSource)
+    } catch (error) {
+      throw new VisionToolkitError('config', `objectStorage.credential "${objectStorageCredentialSource}" is not a valid credential reference`, { cause: error })
+    }
+  }
   const imageInputVariants = config.imageInputVariants ?? {}
   const variantProviders = (imageInputVariants.providers ?? [])
     .map(provider => provider.trim())
@@ -494,6 +553,8 @@ export function resolveConfig(config: VisionToolkitConfig = {}): ResolvedVisionT
       protocol: primary.protocol,
       anthropicThinking: primary.anthropicThinking,
       userAgent: primary.userAgent,
+      stream: primary.stream,
+      uploadViaUrl: primary.uploadViaUrl,
     },
     providers,
     language,
@@ -503,6 +564,12 @@ export function resolveConfig(config: VisionToolkitConfig = {}): ResolvedVisionT
     maxImageBytes,
     maxImagePixels,
     concurrency,
+    objectStorage: {
+      endpoint: objectStorageEndpoint,
+      bucket: objectStorageBucket,
+      ...(objectStorageCredential === undefined ? {} : { credential: objectStorageCredential }),
+      ...(objectStoragePublicBase === undefined || objectStoragePublicBase.length === 0 ? {} : { publicBase: objectStoragePublicBase }),
+    },
     runtime: {
       mode,
       ...(toolkitPath !== undefined ? { agentVisionToolkitPath: toolkitPath } : {}),

package/src/object-storage.ts

@@ -0,0 +1,174 @@
+/**
+ * Minimal S3-compatible object storage bridge used by the URL image-transfer
+ * path. It uploads one image, resolves a model-reachable URL (a configured
+ * public base URL or a temporary presigned URL), and deletes the object after
+ * the vision operation settles. It also provides the Settings "test storage"
+ * probe (upload → head → delete).
+ * @module dsh-vision-toolkit/object-storage
+ */
+
+import { createHash, randomUUID } from 'node:crypto'
+import { readFile } from 'node:fs/promises'
+import { basename } from 'node:path'
+import {
+  DeleteObjectCommand,
+  GetObjectCommand,
+  HeadObjectCommand,
+  PutObjectCommand,
+  S3Client,
+  type S3ClientConfig,
+} from '@aws-sdk/client-s3'
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner'
+import { VisionToolkitError } from './errors.ts'
+
+/** Fully resolved object-storage connection settings (secrets already filled). */
+export interface ObjectStorageSettings {
+  endpoint: string
+  bucket: string
+  accessKeyId: string
+  secretAccessKey: string
+  publicBase?: string
+}
+
+/** Whether the required connection fields are present enough to attempt a request. */
+export function isObjectStorageConfigured(settings: ObjectStorageSettings): boolean {
+  return settings.endpoint.length > 0
+    && settings.bucket.length > 0
+    && settings.accessKeyId.length > 0
+    && settings.secretAccessKey.length > 0
+}
+
+/** Stable object-key prefix so every upload lives under one deletable namespace. */
+const OBJECT_KEY_PREFIX = 'dsh-vision-toolkit'
+
+function encodeKey(key: string): string {
+  return key.split('/').map(encodeURIComponent).join('/')
+}
+
+function clientFor(settings: ObjectStorageSettings): S3Client {
+  const config: S3ClientConfig = {
+    region: 'auto',
+    forcePathStyle: true,
+    credentials: {
+      accessKeyId: settings.accessKeyId,
+      secretAccessKey: settings.secretAccessKey,
+    },
+  }
+  if (settings.endpoint.length > 0) config.endpoint = settings.endpoint
+  return new S3Client(config)
+}
+
+function publicError(error: unknown): string {
+  if (error instanceof Error) return error.message
+  return String(error)
+}
+
+/**
+ * One upload's worth of bookkeeping: the object key and the URL handed to the
+ * model. The key is returned to the runtime so it can delete the object after
+ * the operation settles.
+ */
+export interface UploadedObject {
+  key: string
+  url: string
+}
+
+/** A small S3-compatible object store bound to one bucket and credential. */
+export class ObjectStorageClient {
+  private client?: S3Client
+
+  constructor(private readonly settings: ObjectStorageSettings) {}
+
+  private requireClient(): S3Client {
+    if (this.client === undefined) this.client = clientFor(this.settings)
+    return this.client
+  }
+
+  /** Upload one local image file and resolve its model-reachable URL. */
+  async uploadImage(localPath: string, contentType: string): Promise<UploadedObject> {
+    const body = await readFile(localPath)
+    const digest = createHash('sha256').update(body).digest('hex').slice(0, 12)
+    const name = basename(localPath).replace(/[^A-Za-z0-9._-]/g, '_')
+    const key = `${OBJECT_KEY_PREFIX}/${randomUUID()}-${digest}-${name}`
+    try {
+      await this.requireClient().send(new PutObjectCommand({
+        Bucket: this.settings.bucket,
+        Key: key,
+        Body: body,
+        ContentType: contentType,
+      }))
+    } catch (error) {
+      throw new VisionToolkitError('service', `object storage upload failed: ${publicError(error)}`, { cause: error })
+    }
+    return { key, url: await this.urlFor(key) }
+  }
+
+  /** Resolve the model-reachable URL: public base URL when set, else presigned. */
+  async urlFor(key: string): Promise<string> {
+    if (this.settings.publicBase !== undefined && this.settings.publicBase.length > 0) {
+      return `${this.settings.publicBase}/${encodeKey(key)}`
+    }
+    try {
+      return await getSignedUrl(
+        this.requireClient(),
+        new GetObjectCommand({ Bucket: this.settings.bucket, Key: key }),
+        { expiresIn: 3600 },
+      )
+    } catch (error) {
+      throw new VisionToolkitError('service', `object storage presign failed: ${publicError(error)}`, { cause: error })
+    }
+  }
+
+  /** Delete one uploaded object; failures are logged, never fatal to the call. */
+  async deleteObject(key: string): Promise<void> {
+    try {
+      await this.requireClient().send(new DeleteObjectCommand({
+        Bucket: this.settings.bucket,
+        Key: key,
+      }))
+    } catch {
+      // Best-effort cleanup: a failed delete must not mask the vision result.
+    }
+  }
+
+  /** Settings "test storage" probe: upload a tiny object, head it, then delete it. */
+  async test(): Promise<{ detail: string }> {
+    if (!isObjectStorageConfigured(this.settings)) {
+      throw new VisionToolkitError('config', 'object storage is not fully configured (endpoint, bucket, access key id, and secret access key are required)')
+    }
+    const key = `${OBJECT_KEY_PREFIX}/.connection-test-${randomUUID()}`
+    const marker = `dsh-vision-toolkit object storage test ${Date.now()}`
+    try {
+      await this.requireClient().send(new PutObjectCommand({
+        Bucket: this.settings.bucket,
+        Key: key,
+        Body: marker,
+        ContentType: 'text/plain',
+      }))
+      await this.requireClient().send(new HeadObjectCommand({ Bucket: this.settings.bucket, Key: key }))
+      await this.requireClient().send(new DeleteObjectCommand({ Bucket: this.settings.bucket, Key: key }))
+    } catch (error) {
+      throw new VisionToolkitError('service', `object storage test failed: ${publicError(error)}`, { cause: error })
+    }
+    const urlMode = this.settings.publicBase !== undefined && this.settings.publicBase.length > 0
+      ? `public base ${this.settings.publicBase}`
+      : 'presigned URL'
+    return { detail: `bucket ${this.settings.bucket} reachable; model URLs will use ${urlMode}` }
+  }
+}
+
+/**
+ * Split a credential value of the form `accessKeyId:secretAccessKey` into its
+ * two parts. The access key id never contains a colon, so splitting on the
+ * first colon is safe.
+ */
+export function splitObjectStorageCredential(value: string): { accessKeyId: string; secretAccessKey: string } {
+  const index = value.indexOf(':')
+  if (index <= 0) {
+    throw new VisionToolkitError('config', 'object storage credential must be "accessKeyId:secretAccessKey"')
+  }
+  return {
+    accessKeyId: value.slice(0, index),
+    secretAccessKey: value.slice(index + 1),
+  }
+}

package/src/runtime.ts

@@ -18,6 +18,7 @@ import { isBuiltInFreeVisionProvider, type ResolvedProvider, type ResolvedVision
 import { BUILT_IN_FREE_VISION_KEY } from './defaults.ts'
 import { evidenceRuntimeFingerprint } from './evidence-cache.ts'
 import { VisionToolkitError, type VisionToolkitErrorCode } from './errors.ts'
+import { ObjectStorageClient, splitObjectStorageCredential, type ObjectStorageSettings } from './object-storage.ts'
 import {
   assertDistinctOutput,
   commitStagedDirectory,
@@ -540,6 +541,17 @@ const FORMAT_BY_EXTENSION = new Map([
 ])
 const HEX_COLOR_PATTERN = /^#[0-9A-F]{6}$/
 
+/** MIME type for one analyzed image format, used when uploading to object storage. */
+function imageMimeType(format: string): string {
+  switch (format) {
+    case 'png': return 'image/png'
+    case 'jpeg': return 'image/jpeg'
+    case 'gif': return 'image/gif'
+    case 'webp': return 'image/webp'
+    default: return 'application/octet-stream'
+  }
+}
+
 /**
  * Error codes a provider retries against the SAME provider within its
  * `attempts` budget. Only transient failures are worth re-requesting: a
@@ -968,6 +980,7 @@ export class VisionToolkitRuntime {
       VISION_API_PROTOCOL: provider.protocol === 'anthropic' ? 'anthropic' : 'chat_completions',
       VISION_ANTHROPIC_THINKING: provider.anthropicThinking,
       ...(sslVerify === undefined ? {} : { VISION_SSL_VERIFY: sslVerify }),
+      ...(provider.stream ? { VISION_STREAM: '1' } : {}),
       VISION_USER_AGENT: provider.userAgent,
       LANG: this.config.language,
     }
@@ -984,6 +997,8 @@ export class VisionToolkitRuntime {
         protocol: provider.protocol,
         anthropicThinking: provider.anthropicThinking,
         userAgent: provider.userAgent,
+        stream: provider.stream,
+        uploadViaUrl: provider.uploadViaUrl,
       })
         ? { value: BUILT_IN_FREE_VISION_KEY, source: 'built-in' }
         : await this.ctx.credentials.resolve(provider.credential)
@@ -1253,6 +1268,84 @@ export class VisionToolkitRuntime {
     operation.metrics.imagePixels += image.width * image.height
   }
 
+  /** Resolve the configured object storage into a usable client, or undefined. */
+  private async resolveObjectStorageClient(): Promise<ObjectStorageClient | undefined> {
+    const objectStorage = this.config.objectStorage
+    if (objectStorage.credential === undefined || objectStorage.endpoint.length === 0 || objectStorage.bucket.length === 0) {
+      return undefined
+    }
+    let resolved: ResolvedCredential | undefined
+    try {
+      resolved = await this.ctx.credentials.resolve(objectStorage.credential)
+    } catch {
+      resolved = undefined
+    }
+    if (resolved === undefined) return undefined
+    let accessKeyId: string
+    let secretAccessKey: string
+    try {
+      const split = splitObjectStorageCredential(resolved.value)
+      accessKeyId = split.accessKeyId
+      secretAccessKey = split.secretAccessKey
+    } catch (error) {
+      throw new VisionToolkitError('config', 'object storage credential is malformed', { cause: error })
+    }
+    const settings: ObjectStorageSettings = {
+      endpoint: objectStorage.endpoint,
+      bucket: objectStorage.bucket,
+      accessKeyId,
+      secretAccessKey,
+      ...(objectStorage.publicBase === undefined ? {} : { publicBase: objectStorage.publicBase }),
+    }
+    return new ObjectStorageClient(settings)
+  }
+
+  /**
+   * Upload the prepared images to object storage and return their URLs plus a
+   * cleanup callback, when the primary provider opts into URL transfer and
+   * object storage is configured. Returns undefined otherwise (base64 path).
+   */
+  private async maybeTransferImages(
+    pool: readonly ResolvedProviderEnv[],
+    images: readonly ImageInfo[],
+    operation: OperationContext,
+  ): Promise<{ urls: string[]; cleanup: () => Promise<void> } | undefined> {
+    const primary = pool[0]
+    if (primary === undefined || primary.provider.uploadViaUrl !== true) return undefined
+    const client = await this.resolveObjectStorageClient()
+    if (client === undefined) {
+      throw new VisionToolkitError('config', 'uploadViaUrl is enabled but object storage is not configured')
+    }
+    const keys: string[] = []
+    const urls: string[] = []
+    try {
+      for (const image of images) {
+        if (operation.signal.aborted) throw new VisionToolkitError('cancelled', 'vision image upload cancelled')
+        const uploaded = await client.uploadImage(image.path, imageMimeType(image.format))
+        keys.push(uploaded.key)
+        urls.push(uploaded.url)
+      }
+    } catch (error) {
+      await Promise.allSettled(keys.map(key => client.deleteObject(key)))
+      throw error
+    }
+    return {
+      urls,
+      cleanup: async () => {
+        await Promise.allSettled(keys.map(key => client.deleteObject(key)))
+      },
+    }
+  }
+
+  /** Settings "test storage" probe: upload → head → delete a tiny marker object. */
+  async testObjectStorage(): Promise<{ detail: string }> {
+    const client = await this.resolveObjectStorageClient()
+    if (client === undefined) {
+      throw new VisionToolkitError('config', 'object storage is not configured (endpoint, bucket, and credential are required)')
+    }
+    return client.test()
+  }
+
   /** Stable gate key for one provider's in-flight request cap. */
   private providerGate(provider: ResolvedProvider): Semaphore {
     const key = `${provider.baseUrl}\u0000${provider.model}\u0000${String(provider.credential)}`
@@ -1603,6 +1696,8 @@ export class VisionToolkitRuntime {
         protocol: env.VISION_API_PROTOCOL,
         anthropicThinking: env.VISION_ANTHROPIC_THINKING,
         sslVerify: env.VISION_SSL_VERIFY ?? null,
+        stream: env.VISION_STREAM === '1',
+        uploadViaUrl: provider.uploadViaUrl,
         userAgent: env.VISION_USER_AGENT,
         credentialSha256: createHash('sha256').update(env.VISION_API_KEY).digest('hex'),
         maxImageBytes: provider.maxImageBytes,
@@ -1733,24 +1828,31 @@ export class VisionToolkitRuntime {
           return cached.result
         }
       }
-      const result = await this.runVisionHedge('glance', [
-        ...images.map(image => image.path),
-        ...(request.region !== undefined ? ['--region', request.region] : []),
-        ...(request.ocr === true ? ['--ocr'] : []),
-        ...(request.query !== undefined ? ['-q', request.query] : []),
-      ], images, operation, pool)
-      const answer = result.stdout.trim()
-      if (answer.length === 0) throw new VisionToolkitError('output', 'glance: vision API returned an empty description')
-      const value: GlanceResult = {
-        images,
-        mode: request.ocr === true ? 'ocr' : request.query !== undefined ? 'qa' : 'describe',
-        answer,
-        truncated: false,
-      }
-      if (options.sessionScope !== undefined && cacheKey !== undefined && !operation.signal.aborted) {
-        this.glanceCache.set(options.sessionScope, { key: cacheKey, result: value })
+      const transfer = request.region === undefined
+        ? await this.maybeTransferImages(pool, images, operation)
+        : undefined
+      try {
+        const result = await this.runVisionHedge('glance', [
+          ...(transfer !== undefined ? transfer.urls : images.map(image => image.path)),
+          ...(transfer === undefined && request.region !== undefined ? ['--region', request.region] : []),
+          ...(request.ocr === true ? ['--ocr'] : []),
+          ...(request.query !== undefined ? ['-q', request.query] : []),
+        ], images, operation, pool)
+        const answer = result.stdout.trim()
+        if (answer.length === 0) throw new VisionToolkitError('output', 'glance: vision API returned an empty description')
+        const value: GlanceResult = {
+          images,
+          mode: request.ocr === true ? 'ocr' : request.query !== undefined ? 'qa' : 'describe',
+          answer,
+          truncated: false,
+        }
+        if (options.sessionScope !== undefined && cacheKey !== undefined && !operation.signal.aborted) {
+          this.glanceCache.set(options.sessionScope, { key: cacheKey, result: value })
+        }
+        return value
+      } finally {
+        if (transfer !== undefined) await transfer.cleanup()
       }
-      return value
     })
   }
 
@@ -1786,14 +1888,23 @@ export class VisionToolkitRuntime {
     }
     const image = await this.prepareVisionImage(request.image, pool.map(entry => entry.provider), policy, operation)
     this.accountImage(image, operation)
-    const result = await this.runVisionHedge(tool, [
-      image.path,
-      request.target,
-      ...(request.region !== undefined ? ['--region', request.region] : []),
-    ], [image], operation, pool)
-    const elements = parseLocationOutput(result.stdout)
-    this.validateLocations(elements, image.width, image.height)
-    return { image, elements }
+    const transfer = request.region === undefined
+      ? await this.maybeTransferImages(pool, [image], operation)
+      : undefined
+    try {
+      const result = await this.runVisionHedge(tool, transfer !== undefined
+        ? [transfer.urls[0]!, request.target, '--size', `${image.width}x${image.height}`]
+        : [
+          image.path,
+          request.target,
+          ...(request.region !== undefined ? ['--region', request.region] : []),
+        ], [image], operation, pool)
+      const elements = parseLocationOutput(result.stdout)
+      this.validateLocations(elements, image.width, image.height)
+      return { image, elements }
+    } finally {
+      if (transfer !== undefined) await transfer.cleanup()
+    }
   }
 
   /** ground: locate one named target and return pixel boxes. */

package/src/upstream.ts

@@ -41,6 +41,7 @@ export interface UpstreamEnvironment {
   VISION_API_PROTOCOL: 'chat_completions' | 'anthropic'
   VISION_ANTHROPIC_THINKING: 'omit' | 'disabled' | 'adaptive'
   VISION_SSL_VERIFY?: string
+  VISION_STREAM?: string
   VISION_USER_AGENT: string
   LANG: 'zh' | 'en'
 }
@@ -761,6 +762,9 @@ export class UpstreamAdapter {
           ...(options.env.VISION_SSL_VERIFY === undefined
             ? {}
             : { VISION_SSL_VERIFY: options.env.VISION_SSL_VERIFY }),
+          ...(options.env.VISION_STREAM === undefined
+            ? {}
+            : { VISION_STREAM: options.env.VISION_STREAM }),
           VISION_USER_AGENT: options.env.VISION_USER_AGENT,
           LANG: options.env.LANG,
           VISION_ENV_FILE: join(prepared.cleanHome, 'vision.env'),