@chatcode/cco-llm-chatcode-config 0.1.0

package/vendor/dsh-llm-pi-ai/tests/provider-apis.e2e.ts

@@ -0,0 +1,266 @@
+import { readFile } from 'node:fs/promises'
+import { afterEach, describe, expect, it } from 'vitest'
+import { Context } from '@deepseek-ai/cordis'
+import { AttachmentId, AttachmentStore, ImageVariantId } from '@deepseek-ai/dsh-attachment'
+import type {
+  ImageAttachmentLimits,
+  ImageAttachmentRef,
+  ImageRequestTarget,
+  RequestImageAttachment,
+  SaveImageAttachment,
+  StoredImageAttachment,
+} from '@deepseek-ai/dsh-attachment'
+import LlmRuntime, { createUserMessage, ToolCallId } from '@deepseek-ai/dsh-llm'
+import type { Message, ToolSchema } from '@deepseek-ai/dsh-llm'
+import * as LlmPiAi from '@deepseek-ai/dsh-llm-pi-ai'
+import type { PiAiReplayResponse } from '../src/replay.ts'
+import { assemble, type AssembledResult } from './assemble.ts'
+
+interface ProviderCase {
+  provider: 'openai' | 'anthropic'
+  api: 'openai-responses' | 'anthropic-messages'
+  model: string
+  apiKey?: string
+  baseURL?: string
+  headers?: Record<string, string>
+}
+
+const openAIBaseURL = process.env.DSH_PI_AI_OPENAI_BASE_URL
+const azureOpenAIKey = process.env.AZURE_OPENAI_API_KEY
+// Strictly ANTHROPIC_*: the DeepSeek endpoint does not serve the anthropic-messages
+// protocol, so falling back to DEEPSEEK_API_KEY turns the keyless skip into a 404.
+const anthropicApiKey = process.env.ANTHROPIC_API_KEY
+const anthropicBaseURL = process.env.DSH_PI_AI_ANTHROPIC_BASE_URL
+
+const providerCases: ProviderCase[] = [
+  {
+    provider: 'openai',
+    api: 'openai-responses',
+    model: process.env.DSH_PI_AI_OPENAI_MODEL ?? 'gpt-5.5',
+    ...azureOpenAIKey
+      ? { apiKey: azureOpenAIKey, headers: { 'api-key': azureOpenAIKey, Authorization: '' } }
+      : {},
+    ...openAIBaseURL ? { baseURL: openAIBaseURL } : {},
+  },
+  {
+    provider: 'anthropic',
+    api: 'anthropic-messages',
+    model: process.env.DSH_PI_AI_ANTHROPIC_MODEL ?? 'claude-opus-4-8',
+    ...anthropicApiKey === undefined ? {} : { apiKey: anthropicApiKey },
+    ...anthropicBaseURL === undefined ? {} : { baseURL: anthropicBaseURL },
+  },
+]
+
+const contexts: Context[] = []
+
+async function harness(image?: StoredImageAttachment): Promise<Context> {
+  const ctx = new Context()
+  contexts.push(ctx)
+  await ctx.plugin(LlmRuntime)
+  await ctx.plugin(LlmPiAi, {
+    providers: Object.fromEntries(providerCases.map(profile => [profile.provider, {
+      ...profile.apiKey === undefined ? {} : { apiKey: profile.apiKey },
+      ...profile.baseURL === undefined ? {} : { baseURL: profile.baseURL },
+      ...profile.headers === undefined ? {} : { headers: profile.headers },
+    }])),
+  })
+  if (image !== undefined) {
+    const fixture = image
+    class E2eAttachmentStore extends AttachmentStore {
+      readonly imageLimits: ImageAttachmentLimits = {
+        maxImageBytes: fixture.data.byteLength,
+        maxImagesPerMessage: 1,
+        maxMessageImageBytes: fixture.data.byteLength,
+        maxImagePixels: fixture.ref.width * fixture.ref.height,
+        maxImageDimension: Math.max(fixture.ref.width, fixture.ref.height),
+        mediaTypes: [fixture.ref.mediaType],
+      }
+
+      validateImage(_input: SaveImageAttachment): Promise<void> {
+        return Promise.reject(new Error('e2e attachment fixture is read-only'))
+      }
+
+      saveImage(_input: SaveImageAttachment): Promise<ImageAttachmentRef> {
+        return Promise.reject(new Error('e2e attachment fixture is read-only'))
+      }
+
+      readImage(ref: ImageAttachmentRef): Promise<StoredImageAttachment> {
+        if (ref.attachmentId !== fixture.ref.attachmentId) {
+          return Promise.reject(new Error('unknown e2e attachment fixture'))
+        }
+        return Promise.resolve(fixture)
+      }
+
+      override readImageRequest(ref: ImageAttachmentRef, _policy: ImageRequestTarget): Promise<RequestImageAttachment> {
+        if (ref.attachmentId !== fixture.ref.attachmentId) {
+          return Promise.reject(new Error('unknown e2e attachment fixture'))
+        }
+        return Promise.resolve({
+          variantId: ImageVariantId(`sha256:${'f'.repeat(64)}`),
+          attachment: fixture.ref,
+          data: fixture.data,
+          mediaType: fixture.ref.mediaType,
+          bytes: fixture.data.byteLength,
+          width: fixture.ref.width,
+          height: fixture.ref.height,
+          depth: 'uchar',
+          space: 'srgb',
+          hasAlpha: fixture.ref.mediaType === 'image/png',
+        })
+      }
+    }
+    await ctx.plugin(E2eAttachmentStore)
+  }
+  return ctx
+}
+
+afterEach(async () => {
+  await Promise.all(contexts.splice(0).map(ctx => ctx.fiber.dispose()))
+})
+
+function ask(text: string): Message[] {
+  return [createUserMessage({
+    content: [{ type: 'text', text }],
+    source: { kind: 'plugin', plugin: 'test' },
+  })]
+}
+
+function textOf(result: AssembledResult): string {
+  return result.message.content
+    .filter(block => block.type === 'text')
+    .map(block => block.text)
+    .join('')
+}
+
+function expectFinish(result: AssembledResult, expected: 'stop' | 'tool-calls'): void {
+  if (result.finish.kind === 'error') {
+    throw new Error(`provider request failed (${result.finish.failure.code}): ${result.finish.failure.message}`)
+  }
+  expect(result.finish.kind).toBe(expected)
+}
+
+function expectNativeReplay(result: AssembledResult, profile: ProviderCase): PiAiReplayResponse {
+  const replayState = result.message.source.kind === 'model'
+    ? result.message.source.replayState
+    : undefined
+  expect(replayState).toMatchObject({
+    response: {
+      kind: 'pi-ai',
+      version: 2,
+      api: profile.api,
+      provider: profile.provider,
+      model: profile.model,
+    },
+  })
+  return (replayState as { response: PiAiReplayResponse }).response
+}
+
+const lookupTool: ToolSchema = {
+  name: 'lookup_code',
+  description: 'Look up the word represented by a short code.',
+  parameters: {
+    type: 'object',
+    properties: { code: { type: 'string', description: 'The code to look up.' } },
+    required: ['code'],
+  },
+}
+
+for (const profile of providerCases) {
+  describe.skipIf(profile.apiKey === undefined)(
+    `llm-pi-ai ${profile.provider} e2e (${profile.api})`,
+    () => {
+      it('streams text with usage and native replay metadata', async () => {
+        const ctx = await harness()
+        const result = await assemble(ctx, {
+          provider: profile.provider,
+          model: profile.model,
+          messages: ask('Reply with exactly the word: pong'),
+          maxTokens: 1024,
+        })
+
+        expectFinish(result, 'stop')
+        expect(textOf(result).toLowerCase()).toContain('pong')
+        expect(result.usage?.inputTokens).toBeGreaterThan(0)
+        expect(result.usage?.outputTokens).toBeGreaterThan(0)
+        expect(expectNativeReplay(result, profile).stopReason).toBe('stop')
+      })
+
+      it('round-trips a tool call with provider-native replay metadata', async () => {
+        const ctx = await harness()
+        const prompt = ask('Use lookup_code with code "blue". Do not answer without calling the tool.')
+        const first = await assemble(ctx, {
+          provider: profile.provider,
+          model: profile.model,
+          messages: prompt,
+          tools: [lookupTool],
+          maxTokens: 2048,
+        })
+
+        expectFinish(first, 'tool-calls')
+        const call = first.message.content.find(block => block.type === 'tool-call')
+        expect(call).toBeDefined()
+        expect(call!.name).toBe('lookup_code')
+        expect(JSON.parse(call!.arguments)).toMatchObject({ code: 'blue' })
+        expect(expectNativeReplay(first, profile).stopReason).toBe('toolUse')
+
+        const second = await assemble(ctx, {
+          provider: profile.provider,
+          model: profile.model,
+          messages: [
+            ...prompt,
+            first.message,
+            createUserMessage({
+              content: [{
+                type: 'tool-result',
+                toolCallId: ToolCallId(call!.id),
+                content: [{ type: 'text', text: 'The code blue means ocean.' }],
+              }],
+              source: { kind: 'plugin', plugin: 'test' },
+            }),
+          ],
+          tools: [lookupTool],
+          maxTokens: 2048,
+        })
+
+        expectFinish(second, 'stop')
+        expect(textOf(second).toLowerCase()).toContain('ocean')
+        expect(expectNativeReplay(second, profile).stopReason).toBe('stop')
+      })
+
+      if (profile.provider === 'anthropic') {
+        it('sends a real image through the authenticated Anthropic visual path', async () => {
+          const data = new Uint8Array(await readFile(
+            new URL('./fixtures/qr-code.png', import.meta.url),
+          ))
+          const ref: ImageAttachmentRef = {
+            attachmentId: AttachmentId(`sha256:${'a'.repeat(64)}`),
+            mediaType: 'image/png',
+            bytes: data.byteLength,
+            width: 256,
+            height: 256,
+            name: 'qr-code.png',
+          }
+          const ctx = await harness({ ref, data })
+          const result = await assemble(ctx, {
+            provider: profile.provider,
+            model: profile.model,
+            messages: [createUserMessage({
+              content: [
+                {
+                  type: 'text',
+                  text: 'What type of machine-readable symbol is shown in the attached image? Reply with exactly: QR code',
+                },
+                { type: 'image', attachment: ref },
+              ],
+              source: { kind: 'plugin', plugin: 'test' },
+            })],
+            maxTokens: 256,
+          })
+
+          expectFinish(result, 'stop')
+          expect(textOf(result).toLowerCase()).toContain('qr code')
+        })
+      }
+    },
+  )
+}

package/vendor/dsh-llm-pi-ai/tests/sdk-options.spec.ts

@@ -0,0 +1,106 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import type { StreamChunk } from '@deepseek-ai/dsh-llm'
+import { attributionHeaders } from '@deepseek-ai/dsh-llm'
+
+const streamSimple = vi.hoisted(() => vi.fn())
+
+// A hand-declared route is built by `createProvider` over the protocol table in
+// `src/provider.ts`, so the table's lazy api module is the SDK boundary this
+// test can observe. A catalog route dispatches through pi-ai's own provider and
+// would not see this mock.
+vi.mock('@earendil-works/pi-ai/api/openai-completions.lazy', () => ({
+  openAICompletionsApi: () => ({ stream: streamSimple, streamSimple }),
+}))
+
+import { PiAiAdapter } from '../src/adapter.ts'
+import { resolveProfiles } from '../src/config.ts'
+import { memoryAuth } from './auth-double.ts'
+
+afterEach(() => { streamSimple.mockReset() })
+
+/** A hand-declared OpenAI-compatible route with one fully described model. */
+function gatewayAdapter(reasoningSplit?: boolean): PiAiAdapter {
+  return new PiAiAdapter({
+    profiles: () => resolveProfiles({
+      'local-gateway': {
+        api: 'openai-completions',
+        baseURL: 'http://127.0.0.1:9/v1',
+        models: [{ id: 'local-model', contextWindow: 8192, maxTokens: 1024 }],
+        ...reasoningSplit === undefined ? {} : { reasoningSplit },
+      },
+    }),
+    resolveAuth: () => Promise.resolve({ apiKey: 'test-key' }),
+    auth: memoryAuth(),
+  })
+}
+
+async function drain(adapter: PiAiAdapter): Promise<StreamChunk[]> {
+  const chunks: StreamChunk[] = []
+  for await (const chunk of adapter.stream({
+    provider: 'local-gateway',
+    model: 'local-model',
+    messages: [],
+  })) chunks.push(chunk)
+  return chunks
+}
+
+describe('pi-ai SDK retry boundary', () => {
+  it.each([true, false])('passes an explicit reasoningSplit=%s without changing reasoning effort', async (reasoningSplit) => {
+    streamSimple.mockImplementation(() => { throw new Error('mock SDK boundary') })
+    await drain(gatewayAdapter(reasoningSplit))
+    expect(streamSimple.mock.calls[0]?.[2]).toMatchObject({ samplingParams: { reasoning_split: reasoningSplit } })
+    expect(streamSimple.mock.calls[0]?.[2]).not.toHaveProperty('reasoning')
+  })
+
+  it('uses private auth headers without allowing profile or auth headers to replace attribution', async () => {
+    streamSimple.mockImplementation(() => { throw new Error('mock SDK boundary') })
+    const reserved = Object.keys(attributionHeaders())[0]!
+    const adapter = new PiAiAdapter({
+      profiles: () => resolveProfiles({
+        'local-gateway': {
+          api: 'openai-completions',
+          baseURL: 'http://127.0.0.1:9/v1',
+          headers: { authorization: 'profile', 'X-Profile': 'kept', [reserved.toUpperCase()]: 'profile-spoof' },
+          models: [{ id: 'local-model', contextWindow: 8192, maxTokens: 1024 }],
+        },
+      }),
+      resolveAuth: () => Promise.resolve({ headers: { Authorization: 'Bearer private', 'X-Private': 'auth', [reserved.toUpperCase()]: 'auth-spoof' } }),
+      auth: memoryAuth(),
+    })
+    await drain(adapter)
+    expect(streamSimple.mock.calls[0]?.[2]).toMatchObject({ headers: {
+      'X-Profile': 'kept', Authorization: 'Bearer private', 'X-Private': 'auth', ...attributionHeaders(),
+    } })
+  })
+
+  it('pins one SDK attempt even when the installed provider currently defaults to zero retries', async () => {
+    streamSimple.mockImplementation(() => { throw new Error('mock SDK boundary') })
+
+    const chunks = await drain(gatewayAdapter())
+
+    expect(streamSimple).toHaveBeenCalledOnce()
+    expect(streamSimple.mock.calls[0]?.[2]).toMatchObject({ maxRetries: 0, apiKey: 'test-key' })
+    expect(streamSimple.mock.calls[0]?.[2]).not.toHaveProperty('samplingParams')
+    // pi-ai reports a setup failure as a terminal in-stream error rather than
+    // throwing, which the converter turns into the harness error finish.
+    expect(chunks.at(-1)).toMatchObject({
+      type: 'finish',
+      reason: { kind: 'error', failure: { message: 'mock SDK boundary' } },
+    })
+  })
+
+  it('dispatches a hand-declared route to the endpoint and model its configuration describes', async () => {
+    streamSimple.mockImplementation(() => { throw new Error('mock SDK boundary') })
+
+    await drain(gatewayAdapter())
+
+    expect(streamSimple.mock.calls[0]?.[0]).toMatchObject({
+      id: 'local-model',
+      provider: 'local-gateway',
+      api: 'openai-completions',
+      baseUrl: 'http://127.0.0.1:9/v1',
+      contextWindow: 8192,
+      maxTokens: 1024,
+    })
+  })
+})

package/vendor/dsh-llm-pi-ai/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src/**/*.ts", "tests/**/*.ts"]
+}

package/vendor/dsh-llm-pi-ai/tsconfig.upstream.json

@@ -0,0 +1,51 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "lib/types"
+  },
+  "include": [
+    "src"
+  ],
+  "references": [
+    {
+      "path": "../../util/launch-environment"
+    },
+    {
+      "path": "../../util/brand"
+    },
+    {
+      "path": "../../../vendor/cosmokit"
+    },
+    {
+      "path": "../../../vendor/cordis"
+    },
+    {
+      "path": "../../../vendor/schemastery"
+    },
+    {
+      "path": "../../llm/llm"
+    },
+    {
+      "path": "../../attachment/attachment"
+    },
+    {
+      "path": "../../fs/fs"
+    },
+    {
+      "path": "../../credentials/credentials"
+    },
+    {
+      "path": "../../credentials/authorization"
+    },
+    {
+      "path": "../../settings/settings"
+    },
+    {
+      "path": "../../runtime-diagnostics/invariants"
+    },
+    {
+      "path": "../../util/timeout"
+    }
+  ]
+}