@miaws/miaw 1.18.5 → 1.18.6

package/test/provider/header-timeout.test.ts

@@ -1,233 +0,0 @@
-import { afterEach, expect } from "bun:test"
-import { createServer, type Server } from "node:http"
-import { streamText } from "ai"
-import { Effect, Layer } from "effect"
-import { CrossSpawnSpawner } from "@miaw/core/cross-spawn-spawner"
-import { ProviderV2 } from "@miaw/core/provider"
-import { ModelV2 } from "@miaw/core/model"
-import { disposeAllInstances, provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { testProviderConfig } from "../lib/test-provider"
-import { Env } from "@/env"
-import { Plugin } from "@/plugin"
-import { Provider } from "@/provider/provider"
-import { ProviderError } from "@/provider/error"
-
-afterEach(async () => {
-  await disposeAllInstances()
-})
-
-const it = testEffect(
-  Layer.mergeAll(Provider.defaultLayer, Env.defaultLayer, Plugin.defaultLayer, CrossSpawnSpawner.defaultLayer),
-)
-
-it.live("headerTimeout does not abort delayed SSE body after headers arrive", () =>
-  Effect.gen(function* () {
-    const server = yield* Effect.acquireRelease(
-      Effect.promise(() => delayedBodyServer(1_000)),
-      (server) => Effect.sync(() => server.server.close()),
-    )
-
-    yield* provideTmpdirInstance(
-      () =>
-        Effect.gen(function* () {
-          const provider = yield* Provider.Service
-          const model = yield* provider.getModel(ProviderV2.ID.make("test"), ModelV2.ID.make("test-model"))
-          const result = streamText({
-            model: yield* provider.getLanguage(model),
-            messages: [{ role: "user", content: "hello" }],
-          })
-
-          expect(yield* Effect.promise(() => result.text)).toBe("late")
-        }),
-      { config: providerConfig(server.url, { headerTimeout: 500 }) },
-    )
-  }),
-)
-
-it.live("chunkTimeout raises a response stream error when SSE body stalls", () =>
-  Effect.gen(function* () {
-    const server = yield* Effect.acquireRelease(
-      Effect.promise(() => delayedBodyServer(250)),
-      (server) => Effect.sync(() => server.server.close()),
-    )
-
-    yield* provideTmpdirInstance(
-      () =>
-        Effect.gen(function* () {
-          const provider = yield* Provider.Service
-          const model = yield* provider.getModel(ProviderV2.ID.make("test"), ModelV2.ID.make("test-model"))
-          const result = streamText({
-            model: yield* provider.getLanguage(model),
-            onError() {},
-            messages: [{ role: "user", content: "hello" }],
-          })
-
-          const error = yield* Effect.promise(async () => {
-            try {
-              for await (const part of result.fullStream) {
-                if (part.type === "error") return part.error
-              }
-            } catch (error) {
-              return error
-            }
-          })
-          expect(error).toBeInstanceOf(ProviderError.ResponseStreamError)
-        }),
-      { config: providerConfig(server.url, { chunkTimeout: 50 }) },
-    )
-  }),
-)
-
-it.live("headerTimeout aborts when response headers do not arrive", () =>
-  Effect.gen(function* () {
-    const server = yield* Effect.acquireRelease(
-      Effect.promise(() => delayedHeaderServer(250)),
-      (server) => Effect.sync(() => server.server.close()),
-    )
-
-    yield* provideTmpdirInstance(
-      () =>
-        Effect.gen(function* () {
-          const provider = yield* Provider.Service
-          const model = yield* provider.getModel(ProviderV2.ID.make("test"), ModelV2.ID.make("test-model"))
-          const result = streamText({
-            model: yield* provider.getLanguage(model),
-            onError() {},
-            messages: [{ role: "user", content: "hello" }],
-          })
-
-          const errors = yield* Effect.promise(async () => {
-            const errors: string[] = []
-            for await (const part of result.fullStream) {
-              if (part.type === "error") errors.push(String(part.error))
-            }
-            return errors
-          })
-          expect(errors.join("\n")).toContain("response headers timed out")
-        }),
-      { config: providerConfig(server.url, { headerTimeout: 50 }) },
-    )
-  }),
-)
-
-it.live("headerTimeout is opt-in for non-OpenAI providers", () =>
-  Effect.gen(function* () {
-    const server = yield* Effect.acquireRelease(
-      Effect.promise(() => delayedHeaderServer(100)),
-      (server) => Effect.sync(() => server.server.close()),
-    )
-
-    yield* provideTmpdirInstance(
-      () =>
-        Effect.gen(function* () {
-          const provider = yield* Provider.Service
-          const model = yield* provider.getModel(ProviderV2.ID.make("test"), ModelV2.ID.make("test-model"))
-          const result = streamText({
-            model: yield* provider.getLanguage(model),
-            messages: [{ role: "user", content: "hello" }],
-          })
-
-          expect(yield* Effect.promise(() => result.text)).toBe("ok")
-        }),
-      { config: providerConfig(server.url) },
-    )
-  }),
-)
-
-it.live("OpenAI Codex headerTimeout default can be disabled by config", () =>
-  Effect.gen(function* () {
-    yield* withAuthContent(
-      Effect.gen(function* () {
-        yield* provideTmpdirInstance(
-          () =>
-            Effect.gen(function* () {
-              const provider = yield* Provider.Service
-              const openai = yield* provider.getProvider(ProviderV2.ID.openai)
-              expect(openai.options.headerTimeout).toBe(false)
-            }),
-          { config: { provider: { openai: { options: { headerTimeout: false } } } } },
-        )
-      }),
-    )
-  }),
-)
-
-it.live("OpenAI API auth gets default headerTimeout", () =>
-  Effect.gen(function* () {
-    yield* withAuthContent(
-      Effect.gen(function* () {
-        yield* provideTmpdirInstance(() =>
-          Effect.gen(function* () {
-            const provider = yield* Provider.Service
-            const openai = yield* provider.getProvider(ProviderV2.ID.openai)
-            expect(openai.options.headerTimeout).toBe(10_000)
-          }),
-        )
-      }),
-      { openai: { type: "api", key: "sk-test" } },
-    )
-  }),
-)
-
-function providerConfig(url: string, options: Record<string, unknown> = {}) {
-  const config = testProviderConfig(url)
-  return {
-    ...config,
-    provider: {
-      test: {
-        ...config.provider.test,
-        options: { ...config.provider.test.options, ...options },
-      },
-    },
-  }
-}
-
-async function delayedHeaderServer(delay: number): Promise<{ server: Server; url: string }> {
-  const server = createServer((_, res) => {
-    setTimeout(() => {
-      res.writeHead(200, { "content-type": "text/event-stream" })
-      res.end('data: {"choices":[{"delta":{"content":"ok"}}]}\n\ndata: [DONE]\n\n')
-    }, delay)
-  })
-  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve))
-  const address = server.address()
-  if (!address || typeof address === "string") throw new Error("server did not bind to a TCP port")
-  return { server, url: `http://127.0.0.1:${address.port}` }
-}
-
-async function delayedBodyServer(delay: number): Promise<{ server: Server; url: string }> {
-  const server = createServer((_, res) => {
-    res.writeHead(200, { "content-type": "text/event-stream" })
-    res.flushHeaders()
-    setTimeout(() => {
-      res.end('data: {"choices":[{"delta":{"content":"late"}}]}\n\ndata: [DONE]\n\n')
-    }, delay)
-  })
-  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve))
-  const address = server.address()
-  if (!address || typeof address === "string") throw new Error("server did not bind to a TCP port")
-  return { server, url: `http://127.0.0.1:${address.port}` }
-}
-
-function withAuthContent<A, E, R>(self: Effect.Effect<A, E, R>, value: Record<string, unknown> = defaultAuthContent()) {
-  return Effect.acquireUseRelease(
-    Effect.sync(() => {
-      const previous = process.env.MIAW_AUTH_CONTENT
-      process.env.MIAW_AUTH_CONTENT = JSON.stringify(value)
-      return previous
-    }),
-    () => self,
-    (previous) =>
-      Effect.sync(() => {
-        if (previous === undefined) delete process.env.MIAW_AUTH_CONTENT
-        else process.env.MIAW_AUTH_CONTENT = previous
-      }),
-  )
-}
-
-function defaultAuthContent() {
-  return {
-    openai: { type: "oauth", refresh: "refresh", access: "access", expires: Date.now() + 60_000 },
-  }
-}

package/test/provider/model-status.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
-import { ConfigProviderV1 } from "@miaw/core/v1/config/provider"
-import { CatalogModelStatus, ModelStatus } from "@/provider/model-status"
-import { ModelsDev } from "@miaw/core/models-dev"
-import { Provider } from "@/provider/provider"
-
-describe("provider model status schemas", () => {
-  test("keeps catalog status separate from normalized provider status", () => {
-    expect(Schema.decodeUnknownSync(CatalogModelStatus)("deprecated")).toBe("deprecated")
-    expect(() => Schema.decodeUnknownSync(CatalogModelStatus)("active")).toThrow()
-    expect(Schema.decodeUnknownSync(ModelStatus)("active")).toBe("active")
-  })
-
-  test("accepts active status across public provider schemas", () => {
-    expect(Schema.decodeUnknownSync(ConfigProviderV1.Model)({ status: "active" }).status).toBe("active")
-    expect(
-      Schema.decodeUnknownSync(ModelsDev.Model)({
-        id: "test-model",
-        name: "Test Model",
-        release_date: "2026-01-01",
-        attachment: false,
-        reasoning: false,
-        temperature: true,
-        tool_call: true,
-        limit: { context: 128000, output: 8192 },
-      }).status,
-    ).toBeUndefined()
-    expect(
-      Schema.decodeUnknownSync(Provider.Model)({
-        id: "test-model",
-        providerID: "test-provider",
-        api: {
-          id: "test-model",
-          url: "",
-          npm: "@ai-sdk/openai-compatible",
-        },
-        name: "Test Model",
-        capabilities: {
-          temperature: true,
-          reasoning: false,
-          attachment: false,
-          toolcall: true,
-          input: { text: true, audio: false, image: false, video: false, pdf: false },
-          output: { text: true, audio: false, image: false, video: false, pdf: false },
-          interleaved: false,
-        },
-        cost: {
-          input: 0,
-          output: 0,
-          cache: { read: 0, write: 0 },
-        },
-        limit: { context: 128000, output: 8192 },
-        status: "active",
-        options: {},
-        headers: {},
-        release_date: "2026-01-01",
-      }).status,
-    ).toBe("active")
-  })
-})