clanka 0.6.1 → 0.7.0

package/src/ExaSearch.test.ts

@@ -0,0 +1,106 @@
+import { assert, describe, it } from "@effect/vitest"
+import { Client } from "@modelcontextprotocol/sdk/client"
+import * as Effect from "effect/Effect"
+import * as Cause from "effect/Cause"
+import * as Exit from "effect/Exit"
+import * as Fiber from "effect/Fiber"
+import { afterAll, afterEach, beforeEach, vi } from "vitest"
+import * as ExaSearch from "./ExaSearch.ts"
+
+describe("ExaSearch lazy connection", () => {
+  const connect = vi.spyOn(Client.prototype, "connect")
+  const callTool = vi.spyOn(Client.prototype, "callTool")
+  const close = vi.spyOn(Client.prototype, "close")
+
+  beforeEach(() => {
+    connect.mockResolvedValue(undefined)
+    callTool.mockResolvedValue({
+      content: [{ type: "text", text: "Search results" }],
+    })
+    close.mockResolvedValue(undefined)
+  })
+
+  afterEach(() => {
+    vi.resetAllMocks()
+  })
+
+  afterAll(() => {
+    vi.restoreAllMocks()
+  })
+
+  it.effect("connects lazily and reuses the connection", () =>
+    Effect.gen(function* () {
+      const exa = yield* ExaSearch.ExaSearch
+      assert.strictEqual(connect.mock.calls.length, 0)
+
+      assert.strictEqual(
+        yield* exa.search({ query: "first" }),
+        "Search results",
+      )
+      assert.strictEqual(
+        yield* exa.search({ query: "second" }),
+        "Search results",
+      )
+      assert.strictEqual(connect.mock.calls.length, 1)
+      assert.strictEqual(callTool.mock.calls.length, 2)
+    }).pipe(Effect.provide(ExaSearch.layer)),
+  )
+
+  it.effect(
+    "retries after a failed first connection and then reuses success",
+    () =>
+      Effect.gen(function* () {
+        connect.mockRejectedValueOnce(new Error("temporary failure"))
+        const exa = yield* ExaSearch.ExaSearch
+        yield* Effect.flip(exa.search({ query: "first" }))
+        const retry = yield* Effect.exit(exa.search({ query: "retry" }))
+        assert.strictEqual(connect.mock.calls.length, 2)
+        assert.deepStrictEqual(retry, Exit.succeed("Search results"))
+        assert.strictEqual(
+          yield* exa.search({ query: "third" }),
+          "Search results",
+        )
+        assert.strictEqual(connect.mock.calls.length, 2)
+        assert.strictEqual(callTool.mock.calls.length, 2)
+      }).pipe(Effect.provide(ExaSearch.layer)),
+  )
+
+  it.effect(
+    "retries after interruption instead of cancelling later searches",
+    () =>
+      Effect.gen(function* () {
+        const started = Promise.withResolvers<void>()
+        let signal: AbortSignal | undefined
+        connect.mockImplementationOnce((_transport, options) => {
+          signal = options?.signal
+          started.resolve()
+          return new Promise<void>((_resolve, reject) => {
+            signal?.addEventListener("abort", () => reject(signal?.reason), {
+              once: true,
+            })
+          })
+        })
+        const exa = yield* ExaSearch.ExaSearch
+        const first = yield* exa
+          .search({ query: "first" })
+          .pipe(Effect.forkChild)
+        yield* Effect.promise(() => started.promise)
+        yield* Fiber.interrupt(first)
+        const interrupted = yield* Fiber.await(first)
+        assert.isTrue(
+          Exit.isFailure(interrupted) &&
+            Cause.hasInterruptsOnly(interrupted.cause),
+        )
+        assert.isTrue(signal?.aborted)
+        assert.strictEqual(callTool.mock.calls.length, 0)
+        const retry = yield* Effect.exit(exa.search({ query: "retry" }))
+        assert.strictEqual(connect.mock.calls.length, 2)
+        assert.deepStrictEqual(retry, Exit.succeed("Search results"))
+        assert.strictEqual(
+          yield* exa.search({ query: "third" }),
+          "Search results",
+        )
+        assert.strictEqual(connect.mock.calls.length, 2)
+      }).pipe(Effect.provide(ExaSearch.layer)),
+  )
+})

package/src/ExaSearch.ts

@@ -1,7 +1,9 @@
 /**
  * @since 1.0.0
  */
+import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
 import { pipe } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Schema from "effect/Schema"
@@ -55,7 +57,10 @@ export const layer = Layer.effect(
   Effect.gen(function* () {
     const client = yield* McpClient.McpClient
 
-    yield* client.connect({ url: "https://mcp.exa.ai/mcp" }).pipe(Effect.orDie)
+    const connect = yield* Effect.cachedWithTTL(
+      client.connect({ url: "https://mcp.exa.ai/mcp" }),
+      (exit) => (Exit.isSuccess(exit) ? Duration.infinity : Duration.zero),
+    )
 
     const decode = Schema.decodeUnknownEffect(
       Schema.NonEmptyArray(ExaSearchResult),
@@ -64,6 +69,7 @@ export const layer = Layer.effect(
     return ExaSearch.of({
       search: Effect.fn("ExaSearch.search")(
         function* (options) {
+          yield* connect
           const results = yield* pipe(
             client.toolCall({
               name: "web_search_exa",

package/src/Xai.test.ts

@@ -0,0 +1,160 @@
+import { assert, describe, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as Layer from "effect/Layer"
+import * as Stream from "effect/Stream"
+import * as LanguageModel from "effect/unstable/ai/LanguageModel"
+import * as Model from "effect/unstable/ai/Model"
+import {
+  HttpClient,
+  type HttpClientRequest,
+  HttpClientResponse,
+} from "effect/unstable/http"
+import * as KeyValueStore from "effect/unstable/persistence/KeyValueStore"
+import * as Compaction from "./Compaction.ts"
+import { DeviceCodeHandler } from "./DeviceCodeHandler.ts"
+import * as Public from "./index.ts"
+import * as Xai from "./Xai.ts"
+import { TokenData, toTokenStore } from "./XaiAuth.ts"
+
+const capture = () => {
+  const requests: Array<HttpClientRequest.HttpClientRequest> = []
+  const client = HttpClient.make((request) =>
+    Effect.sync(() => {
+      requests.push(request)
+      return HttpClientResponse.fromWeb(
+        request,
+        new Response(
+          JSON.stringify({
+            error: {
+              message: "transport probe",
+              type: "invalid_request_error",
+            },
+          }),
+          { status: 400, headers: { "content-type": "application/json" } },
+        ),
+      )
+    }),
+  )
+  return { requests, layer: Layer.succeed(HttpClient.HttpClient, client) }
+}
+const body = (
+  request: HttpClientRequest.HttpClientRequest,
+): Record<string, unknown> => {
+  if (request.body._tag !== "Uint8Array") throw new Error("Expected JSON body")
+  return JSON.parse(new TextDecoder().decode(request.body.body))
+}
+const seed = Effect.gen(function* () {
+  yield* toTokenStore(yield* KeyValueStore.KeyValueStore)
+    .set(
+      "token",
+      new TokenData({
+        access: "subscription-token",
+        refresh: "refresh",
+        expires: Date.now() + 3600000,
+      }),
+    )
+    .pipe(Effect.orDie)
+})
+const noLogin = Layer.succeed(DeviceCodeHandler, {
+  onCode: () => Effect.die("Cached credentials must not prompt"),
+})
+
+describe("Xai provider", () => {
+  it("exports Xai, but not XaiAuth, from the public entry point", () => {
+    assert.strictEqual(Public.Xai, Xai)
+    assert.isFalse("XaiAuth" in Public)
+    assert.strictEqual(Xai.model("grok-4.6").provider, "xai")
+  })
+
+  for (const effort of [undefined, "low"] as const) {
+    it.effect(
+      "uses authenticated HTTP Responses with " +
+        (effort ?? "default high") +
+        " reasoning",
+      () =>
+        Effect.gen(function* () {
+          yield* seed
+          const http = capture()
+          yield* Effect.gen(function* () {
+            assert.lengthOf(
+              http.requests,
+              0,
+              "Client construction must not trigger login or inference",
+            )
+            assert.strictEqual(yield* Model.ProviderName, "xai")
+            assert.strictEqual(yield* Model.ModelName, "grok-4.6")
+            const ai = yield* LanguageModel.LanguageModel
+            const exit = yield* ai
+              .streamText({ prompt: "hello" })
+              .pipe(Stream.runDrain, Effect.exit)
+            assert.isTrue(Exit.isFailure(exit))
+          }).pipe(
+            Effect.provide(
+              Xai.model(
+                "grok-4.6",
+                effort === undefined ? undefined : { reasoning: { effort } },
+              ).pipe(
+                Layer.provide(Xai.layerClient),
+                Layer.provide(http.layer),
+                Layer.provide(noLogin),
+              ),
+            ),
+          )
+          assert.lengthOf(http.requests, 1)
+          const request = http.requests[0]!
+          assert.strictEqual(request.method, "POST")
+          assert.strictEqual(request.url, "https://api.x.ai/v1/responses")
+          assert.strictEqual(
+            request.headers.authorization,
+            "Bearer subscription-token",
+          )
+          assert.match(request.headers["user-agent"]!, /clanka/i)
+          assert.notMatch(request.headers["user-agent"]!, /opencode/i)
+          assert.deepInclude(body(request), {
+            model: "grok-4.6",
+            store: false,
+            stream: true,
+          })
+          assert.deepInclude(body(request).reasoning, {
+            effort: effort ?? "high",
+          })
+          assert.isFalse("max_output_tokens" in body(request))
+        }).pipe(Effect.provide(KeyValueStore.layerMemory)),
+    )
+  }
+
+  it.effect(
+    "caps summaries at 4k without leaking the cap into subsequent requests",
+    () =>
+      Effect.gen(function* () {
+        yield* seed
+        const http = capture()
+        yield* Effect.gen(function* () {
+          const ai = yield* LanguageModel.LanguageModel
+          const summarize = yield* Compaction.SummarizerTransform
+          yield* summarize(
+            ai.streamText({ prompt: "summarize" }).pipe(Stream.runDrain),
+          ).pipe(Effect.exit)
+          yield* ai
+            .streamText({ prompt: "continue" })
+            .pipe(Stream.runDrain, Effect.exit)
+        }).pipe(
+          Effect.provide(
+            Xai.model("grok-4.6").pipe(
+              Layer.provide(Xai.layerClient),
+              Layer.provide(http.layer),
+              Layer.provide(noLogin),
+            ),
+          ),
+        )
+        assert.lengthOf(http.requests, 2)
+        assert.strictEqual(body(http.requests[0]!).max_output_tokens, 4000)
+        assert.isFalse("max_output_tokens" in body(http.requests[1]!))
+        for (const request of http.requests) {
+          assert.strictEqual(request.url, "https://api.x.ai/v1/responses")
+          assert.strictEqual(body(request).store, false)
+        }
+      }).pipe(Effect.provide(KeyValueStore.layerMemory)),
+  )
+})

package/src/Xai.ts

@@ -0,0 +1,57 @@
+/**
+ * @since 1.0.0
+ */
+import { OpenAiClient, OpenAiLanguageModel } from "@effect/ai-openai"
+import * as Layer from "effect/Layer"
+import * as Struct from "effect/Struct"
+import { XaiAuth } from "./XaiAuth.ts"
+import { AgentModelConfig } from "./Agent.ts"
+import * as Compaction from "./Compaction.ts"
+import * as Model from "effect/unstable/ai/Model"
+import type * as LanguageModel from "effect/unstable/ai/LanguageModel"
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerClient = OpenAiClient.layer({
+  apiUrl: "https://api.x.ai/v1",
+}).pipe(Layer.provide(XaiAuth.layerClient))
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const model = (
+  model: string,
+  options?:
+    | (OpenAiLanguageModel.Config["Service"] & typeof AgentModelConfig.Service)
+    | undefined,
+): Model.Model<"xai", LanguageModel.LanguageModel, OpenAiClient.OpenAiClient> =>
+  Model.make(
+    "xai",
+    model,
+    Layer.mergeAll(
+      OpenAiLanguageModel.layer({
+        model,
+        config: {
+          ...Struct.omit(options ?? {}, [
+            "systemPromptTransform",
+            "supportsImages",
+          ]),
+          store: false,
+          reasoning: { effort: "high", ...options?.reasoning },
+        },
+      }),
+      AgentModelConfig.layer({
+        systemPromptTransform: options?.systemPromptTransform,
+        supportsImages: options?.supportsImages,
+      }),
+      // Cap compaction summaries; xAI honours max_output_tokens.
+      Layer.succeed(Compaction.SummarizerTransform, (effect) =>
+        OpenAiLanguageModel.withConfigOverride(effect, {
+          max_output_tokens: Compaction.summarizerMaxOutputTokens,
+        }),
+      ),
+    ),
+  )