dsh-edge 0.1.0

package/src/deepseek.ts

@@ -0,0 +1,231 @@
+import type { AnonymousUserId } from '@deepseek-ai/dsh-anonymous-user-id'
+import type { CredentialRef } from '@deepseek-ai/dsh-credentials'
+import {
+  LlmAdapter,
+  LlmError,
+  assertUsableApiKey,
+  resolveRetryPolicy,
+  type GenerateOptions,
+  type LlmModelInfo,
+  type LlmProviderInfo,
+  type LlmResolvedModelInfo,
+  type ResolvedRetryPolicy,
+  type StreamChunk,
+} from '@deepseek-ai/dsh-llm'
+import type { SessionId } from '@deepseek-ai/dsh-session'
+import {
+  DEFAULT_CONTEXT_WINDOW,
+  DeepSeekAdapter,
+  type DeepSeekConnectionOptions,
+} from '@deepseek-ai/dsh-llm-deepseek'
+
+const API_KEY_REF = 'DEEPSEEK_API_KEY' as CredentialRef
+const DEFAULT_BASE_URL = 'https://api.deepseek.com'
+const DEFAULT_MAX_TOKENS = 8_192
+const DEFAULT_MODEL = 'deepseek-v4-flash'
+const DEFAULT_REASONING_EFFORT = 'off'
+const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 120_000
+const MAX_TIMER_DELAY_MS = 2_147_483_647
+const MODEL_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._:/-]{0,127}$/
+
+export type EdgeReasoningEffort = 'off' | 'low' | 'high' | 'max'
+
+/** Resolve and validate the DeepSeek HTTP endpoint selected by deployment configuration. */
+export function resolveEdgeBaseURL(raw?: string): string {
+  const value = raw ?? DEFAULT_BASE_URL
+  let parsed: URL
+  try {
+    parsed = new URL(value)
+  } catch {
+    throw new Error('dsh-edge: DEEPSEEK_BASE_URL must be a valid HTTP(S) URL')
+  }
+  if ((parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+    || parsed.username.length > 0
+    || parsed.password.length > 0) {
+    throw new Error('dsh-edge: DEEPSEEK_BASE_URL must be a valid HTTP(S) URL without credentials')
+  }
+  return value
+}
+
+/** Resolve the DeepSeek model id selected by Worker deployment configuration. */
+export function resolveEdgeModel(raw?: string): string {
+  if (raw === undefined) return DEFAULT_MODEL
+  if (!MODEL_PATTERN.test(raw)) {
+    throw new Error('dsh-edge: DEEPSEEK_MODEL must be a valid model id of at most 128 characters')
+  }
+  return raw
+}
+
+/** Resolve the DeepSeek thinking policy selected by Worker deployment configuration. */
+export function resolveEdgeReasoningEffort(raw?: string): EdgeReasoningEffort {
+  if (raw === undefined) return DEFAULT_REASONING_EFFORT
+  if (raw !== 'off' && raw !== 'low' && raw !== 'high' && raw !== 'max') {
+    throw new Error('dsh-edge: DEEPSEEK_REASONING_EFFORT must be one of off, low, high, or max')
+  }
+  return raw
+}
+
+/** Resolve the optional Worker deployment override before an SSE turn opens. */
+export function resolveEdgeStreamIdleTimeoutMs(raw?: string): number {
+  if (raw === undefined) return DEFAULT_STREAM_IDLE_TIMEOUT_MS
+  if (!/^[1-9]\d*$/.test(raw)) {
+    throw new Error(
+      'dsh-edge: DEEPSEEK_STREAM_IDLE_TIMEOUT_MS must be a positive integer',
+    )
+  }
+  const value = Number(raw)
+  if (!Number.isSafeInteger(value) || value > MAX_TIMER_DELAY_MS) {
+    throw new Error(
+      `dsh-edge: DEEPSEEK_STREAM_IDLE_TIMEOUT_MS must be no greater than ${MAX_TIMER_DELAY_MS}`,
+    )
+  }
+  return value
+}
+
+/** Resolve the request output cap selected by Worker deployment configuration. */
+export function resolveEdgeMaxOutputTokens(raw?: string): number {
+  if (raw === undefined) return DEFAULT_MAX_TOKENS
+  if (!/^[1-9]\d*$/.test(raw)) {
+    throw new Error(
+      'dsh-edge: DEEPSEEK_MAX_OUTPUT_TOKENS must be a positive integer',
+    )
+  }
+  const value = Number(raw)
+  if (!Number.isSafeInteger(value)) {
+    throw new Error(
+      `dsh-edge: DEEPSEEK_MAX_OUTPUT_TOKENS must be no greater than ${Number.MAX_SAFE_INTEGER}`,
+    )
+  }
+  return value
+}
+
+/** Construct one turn-scoped DSH DeepSeek adapter that resolves its bearer token per operation. */
+function createEdgeDeepSeekModel(options: {
+  resolveApiKey: () => Promise<string | undefined>
+  baseURL?: string
+  maxTokens?: number
+  reasoningEffort?: EdgeReasoningEffort
+  streamIdleTimeoutMs?: number
+}): DeepSeekAdapter {
+  const connection: DeepSeekConnectionOptions = {
+    apiKeyEnv: API_KEY_REF,
+    baseURL: options.baseURL ?? DEFAULT_BASE_URL,
+    defaults: { reasoningEffort: options.reasoningEffort ?? DEFAULT_REASONING_EFFORT },
+    maxTokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
+    defaultContextWindow: DEFAULT_CONTEXT_WINDOW,
+    models: [],
+    streamIdleTimeoutMs: options.streamIdleTimeoutMs ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS,
+    retryPolicy: resolveRetryPolicy(undefined, 'dsh-edge.retryPolicy'),
+  }
+  const anonymousRequestId = crypto.randomUUID() as AnonymousUserId
+  return new DeepSeekAdapter({
+    options: () => connection,
+    resolveApiKey: async () => {
+      const apiKey = await options.resolveApiKey()
+      if (apiKey === undefined) {
+        throw new LlmError(
+          'dsh-edge: no API key for provider route "deepseek-official"; configure the DEEPSEEK_API_KEY Worker secret',
+          'MISSING_CREDENTIAL',
+        )
+      }
+      return assertUsableApiKey(apiKey, 'dsh-edge', API_KEY_REF)
+    },
+    // Provider telemetry must not derive identity from the owner or Durable Object id.
+    resolveUserId: () => anonymousRequestId,
+  })
+}
+
+/**
+ * One upstream LLM route with per-turn deployment configuration selected by
+ * the loop-stamped session id. Credentials resolve independently through the
+ * upstream credential service for each model operation.
+ */
+export class EdgeDeepSeekAdapter extends LlmAdapter {
+  private readonly active = new Map<SessionId, LlmAdapter>()
+  private metadataMaxTokens = DEFAULT_MAX_TOKENS
+  private metadataReasoningEffort: EdgeReasoningEffort = DEFAULT_REASONING_EFFORT
+  private metadata: DeepSeekAdapter
+
+  constructor(private readonly resolveApiKey?: () => Promise<string | undefined>) {
+    super()
+    this.metadata = createEdgeDeepSeekModel({
+      resolveApiKey: () => Promise.resolve('dsh-edge-model-metadata'),
+    })
+  }
+
+  bind(sessionId: SessionId, options: {
+    baseURL?: string
+    maxTokens?: number
+    reasoningEffort?: EdgeReasoningEffort
+    streamIdleTimeoutMs?: number
+  }): () => void {
+    this.configureDefaults(
+      options.maxTokens ?? DEFAULT_MAX_TOKENS,
+      options.reasoningEffort ?? DEFAULT_REASONING_EFFORT,
+    )
+    return this.bindAdapter(sessionId, createEdgeDeepSeekModel({
+      ...options,
+      resolveApiKey: this.resolveApiKey ?? (() => Promise.resolve(undefined)),
+    }))
+  }
+
+  private configureDefaults(
+    maxTokens: number,
+    reasoningEffort: EdgeReasoningEffort,
+  ): void {
+    if (maxTokens === this.metadataMaxTokens
+      && reasoningEffort === this.metadataReasoningEffort) return
+    if (this.active.size > 0) {
+      throw new LlmError(
+        'dsh-edge: deployment model defaults changed while another session is active',
+        'EDGE_MODEL_BUSY',
+      )
+    }
+    this.metadata = createEdgeDeepSeekModel({
+      resolveApiKey: () => Promise.resolve('dsh-edge-model-metadata'),
+      maxTokens,
+      reasoningEffort,
+    })
+    this.metadataMaxTokens = maxTokens
+    this.metadataReasoningEffort = reasoningEffort
+  }
+
+  bindAdapter(sessionId: SessionId, adapter: LlmAdapter): () => void {
+    if (this.active.has(sessionId)) {
+      throw new LlmError(`dsh-edge: model is already bound for session "${sessionId}"`, 'EDGE_MODEL_BUSY')
+    }
+    this.active.set(sessionId, adapter)
+    return () => {
+      if (this.active.get(sessionId) === adapter) this.active.delete(sessionId)
+    }
+  }
+
+  override providerInfo(provider: string): LlmProviderInfo {
+    return this.metadata.providerInfo(provider)
+  }
+
+  override providerRetryPolicy(provider: string): ResolvedRetryPolicy {
+    return this.metadata.providerRetryPolicy(provider)
+  }
+
+  override listModels(provider: string): Promise<readonly LlmModelInfo[]> {
+    return this.metadata.listModels(provider)
+  }
+
+  override resolveModel(
+    provider: string,
+    model: string,
+    signal?: AbortSignal,
+  ): Promise<LlmResolvedModelInfo> {
+    return this.metadata.resolveModel(provider, model, signal)
+  }
+
+  override stream(options: GenerateOptions): AsyncIterable<StreamChunk> {
+    const sessionId = options.sessionId
+    const adapter = sessionId === undefined ? undefined : this.active.get(sessionId)
+    if (adapter === undefined) {
+      throw new LlmError('dsh-edge: no request-scoped DeepSeek configuration is bound', 'EDGE_MODEL_NOT_BOUND')
+    }
+    return adapter.stream(options)
+  }
+}

package/src/deployment.ts

@@ -0,0 +1,147 @@
+/** Deployment configuration shared by Edge health and turn admission. */
+
+import type { EdgeReasoningEffort } from './deepseek.ts'
+import {
+  resolveEdgeBaseURL,
+  resolveEdgeMaxOutputTokens,
+  resolveEdgeModel,
+  resolveEdgeReasoningEffort,
+  resolveEdgeStreamIdleTimeoutMs,
+} from './deepseek.ts'
+import { resolveDeepSeekApiKey } from './http.ts'
+import { resolveEdgeSearchBaseURL } from './web-search.ts'
+import {
+  resolveEdgeCommandTimeoutPolicy,
+  type EdgeCommandTimeoutPolicy,
+} from './workspace.ts'
+import { DSH_EDGE_UPSTREAM_VERSION, DSH_EDGE_VERSION } from './release.ts'
+
+declare const __DSH_EDGE_DEPLOYMENT_ID__: string | undefined
+
+const LOCAL_DEPLOYMENT_ID = 'local-development'
+
+/** Worker variables that control one Edge model and shell turn. */
+export interface EdgeDeploymentConfigSource {
+  LOADER?: unknown
+  DEEPSEEK_API_KEY?: string
+  DEEPSEEK_BASE_URL?: string
+  DEEPSEEK_MAX_OUTPUT_TOKENS?: string
+  DEEPSEEK_MODEL?: string
+  DEEPSEEK_REASONING_EFFORT?: string
+  DEEPSEEK_SEARCH_BASE_URL?: string
+  DEEPSEEK_STREAM_IDLE_TIMEOUT_MS?: string
+  DSH_EDGE_DEFAULT_COMMAND_TIMEOUT_MS?: string
+  DSH_EDGE_MAX_COMMAND_TIMEOUT_MS?: string
+}
+
+/** Validated deployment choices consumed by one Edge turn. */
+export interface EdgeDeploymentConfig {
+  baseURL: string
+  maxTokens: number
+  model: string
+  reasoningEffort: EdgeReasoningEffort
+  searchBaseURL: string
+  streamIdleTimeoutMs: number
+  commandTimeoutPolicy: EdgeCommandTimeoutPolicy
+}
+
+/** Secret-free deployment facts safe to project to the authenticated owner. */
+export interface EdgeDeploymentProfile {
+  shell: 'just-bash-direct' | 'just-bash-isolated'
+  storage: 'durable-object-sqlite-vfs'
+  deploymentId: string
+  apiKeyConfigured: boolean
+  baseURL: string
+  maxTokens: number
+  model: string
+  reasoningEffort: EdgeReasoningEffort
+  searchBaseURL: string
+  streamIdleTimeoutMs: number
+  commandTimeoutPolicy: EdgeCommandTimeoutPolicy
+}
+
+/** Identify the exact Worker artifact that answered a readiness request. */
+export function resolveEdgeDeploymentId(): string {
+  return typeof __DSH_EDGE_DEPLOYMENT_ID__ === 'string'
+    ? __DSH_EDGE_DEPLOYMENT_ID__
+    : LOCAL_DEPLOYMENT_ID
+}
+
+/** Resolve every deployment choice before health succeeds or a turn is claimed. */
+export function resolveEdgeDeploymentConfig(
+  source: EdgeDeploymentConfigSource,
+): EdgeDeploymentConfig {
+  resolveDeepSeekApiKey(source.DEEPSEEK_API_KEY)
+  return {
+    baseURL: resolveEdgeBaseURL(source.DEEPSEEK_BASE_URL),
+    maxTokens: resolveEdgeMaxOutputTokens(source.DEEPSEEK_MAX_OUTPUT_TOKENS),
+    model: resolveEdgeModel(source.DEEPSEEK_MODEL),
+    reasoningEffort: resolveEdgeReasoningEffort(source.DEEPSEEK_REASONING_EFFORT),
+    searchBaseURL: resolveEdgeSearchBaseURL(source.DEEPSEEK_SEARCH_BASE_URL),
+    streamIdleTimeoutMs: resolveEdgeStreamIdleTimeoutMs(
+      source.DEEPSEEK_STREAM_IDLE_TIMEOUT_MS,
+    ),
+    commandTimeoutPolicy: resolveEdgeCommandTimeoutPolicy(
+      source.DSH_EDGE_DEFAULT_COMMAND_TIMEOUT_MS,
+      source.DSH_EDGE_MAX_COMMAND_TIMEOUT_MS,
+    ),
+  }
+}
+
+/** Whether the deployment supplies a non-blank DeepSeek Worker binding. */
+export function edgeDeploymentApiKeyConfigured(source: EdgeDeploymentConfigSource): boolean {
+  return typeof source.DEEPSEEK_API_KEY === 'string'
+    && source.DEEPSEEK_API_KEY.trim().length > 0
+}
+
+/** Omit URL components that commonly carry credentials from the browser projection. */
+function projectedEdgeBaseURL(raw?: string): string {
+  const value = resolveEdgeBaseURL(raw)
+  const parsed = new URL(value)
+  if (parsed.search.length === 0 && parsed.hash.length === 0) return value
+  parsed.search = ''
+  parsed.hash = ''
+  return parsed.href
+}
+
+/** Resolve the effective runtime profile without retaining or returning a credential value. */
+export function resolveEdgeDeploymentProfile(
+  source: EdgeDeploymentConfigSource,
+): EdgeDeploymentProfile {
+  return {
+    shell: source.LOADER === undefined ? 'just-bash-direct' : 'just-bash-isolated',
+    storage: 'durable-object-sqlite-vfs',
+    deploymentId: resolveEdgeDeploymentId(),
+    apiKeyConfigured: edgeDeploymentApiKeyConfigured(source),
+    baseURL: projectedEdgeBaseURL(source.DEEPSEEK_BASE_URL),
+    maxTokens: resolveEdgeMaxOutputTokens(source.DEEPSEEK_MAX_OUTPUT_TOKENS),
+    model: resolveEdgeModel(source.DEEPSEEK_MODEL),
+    reasoningEffort: resolveEdgeReasoningEffort(source.DEEPSEEK_REASONING_EFFORT),
+    searchBaseURL: resolveEdgeSearchBaseURL(source.DEEPSEEK_SEARCH_BASE_URL),
+    streamIdleTimeoutMs: resolveEdgeStreamIdleTimeoutMs(
+      source.DEEPSEEK_STREAM_IDLE_TIMEOUT_MS,
+    ),
+    commandTimeoutPolicy: resolveEdgeCommandTimeoutPolicy(
+      source.DSH_EDGE_DEFAULT_COMMAND_TIMEOUT_MS,
+      source.DSH_EDGE_MAX_COMMAND_TIMEOUT_MS,
+    ),
+  }
+}
+
+/** Validate the default turn configuration and return the public runtime identity. */
+export function resolveEdgeDeploymentHealth(source: EdgeDeploymentConfigSource) {
+  resolveEdgeDeploymentConfig(source)
+  const profile = resolveEdgeDeploymentProfile(source)
+  return {
+    ok: true,
+    service: 'dsh-edge',
+    storage: profile.storage,
+    shell: profile.shell,
+    agent: 'upstream-react-loop-agent',
+    access: 'single-owner-cookie',
+    deploymentId: profile.deploymentId,
+    version: DSH_EDGE_VERSION,
+    upstreamVersion: DSH_EDGE_UPSTREAM_VERSION,
+    status: 'ready',
+  } as const
+}

package/src/direct-shell-core-empty.ts

@@ -0,0 +1,10 @@
+/**
+ * Direct-build replacement for Computer's embedded Dynamic Worker modules.
+ *
+ * Direct deployments have no Loader binding, so they cannot select
+ * `WorkerShellBackend`. The alias keeps Computer's filesystem and command
+ * adapters available without uploading an unreachable shell runtime.
+ */
+const directShellCore = Object.freeze({})
+
+export default directShellCore

package/src/direct-shell-protocol.ts

@@ -0,0 +1,5 @@
+/** Byte ceiling shared by shell execution, retention, and truncation rendering. */
+export const EDGE_SHELL_OUTPUT_LIMIT_BYTES = 65_536
+
+/** Standard shell-event result used when direct just-bash stops at its output budget. */
+export const DIRECT_SHELL_OUTPUT_TRUNCATED = 'dsh-edge:direct-output-truncated'