Enforce strict Effect tsgo migrations

ts/packages/flow/src/model/text-completion/claude.ts

@@ -15,9 +15,15 @@ import {
   type ProcessorConfig,
   type LlmResult,
   type LlmChunk,
-  tooManyRequestsError,
 } from "@trustgraph/base";
-import { Effect, Layer } from "effect";
+import { Effect, Layer, Stream } from "effect";
+import {
+  optionalStringConfig,
+  providerStatusError,
+  requiredString,
+  toAsyncGenerator,
+  type TextCompletionRuntimeError,
+} from "./common.ts";
 
 export type ClaudeProcessorConfig = ProcessorConfig & {
   model?: string;
@@ -26,21 +32,46 @@ export type ClaudeProcessorConfig = ProcessorConfig & {
   maxOutput?: number;
 };
 
+type ResolvedClaudeConfig = {
+  readonly defaultModel: string;
+  readonly defaultTemperature: number;
+  readonly maxOutput: number;
+  readonly apiKey: string;
+};
+
+const loadClaudeConfig = Effect.fn("loadClaudeConfig")(function*(config: ClaudeProcessorConfig) {
+    const apiKey = yield* requiredString(
+      config.apiKey ?? (yield* optionalStringConfig("Claude", "CLAUDE_KEY")),
+      "Claude",
+      "CLAUDE_KEY",
+      "Claude API key not specified",
+    );
+
+    return {
+      defaultModel: config.model ?? "claude-sonnet-4-20250514",
+      defaultTemperature: config.temperature ?? 0.0,
+      maxOutput: config.maxOutput ?? 8192,
+      apiKey,
+    } satisfies ResolvedClaudeConfig;
+});
+
+const mapClaudeError = (error: unknown): TextCompletionRuntimeError =>
+  providerStatusError("Claude", error);
+
 export function makeClaudeProvider(config: ClaudeProcessorConfig): LlmProvider {
-  const defaultModel = config.model ?? "claude-sonnet-4-20250514";
-  const defaultTemperature = config.temperature ?? 0.0;
-  const maxOutput = config.maxOutput ?? 8192;
-    const apiKey = config.apiKey ?? process.env.CLAUDE_KEY;
-    if (apiKey === undefined || apiKey.length === 0) {
-      throw new Error("Claude API key not specified");
-    }
+  const {
+    defaultModel,
+    defaultTemperature,
+    maxOutput,
+    apiKey,
+  } = Effect.runSync(loadClaudeConfig(config)) satisfies ResolvedClaudeConfig;
 
   const client = new Anthropic({ apiKey });
 
-    console.log("[Claude] LLM service initialized");
+  Effect.runSync(Effect.log("[Claude] LLM service initialized"));
 
   return {
-    generateContent: async (
+    generateContent: (
       system: string,
       prompt: string,
       model?: string,
@@ -49,88 +80,120 @@ export function makeClaudeProvider(config: ClaudeProcessorConfig): LlmProvider {
       const modelName = model ?? defaultModel;
       const temp = temperature ?? defaultTemperature;
 
-      try {
-        const response = await client.messages.create({
-          model: modelName,
-          max_tokens: maxOutput,
-          temperature: temp,
-          system,
-          messages: [
-            { role: "user", content: prompt },
-          ],
-        });
+      return Effect.runPromise(
+        Effect.tryPromise({
+          try: () =>
+            client.messages.create({
+              model: modelName,
+              max_tokens: maxOutput,
+              temperature: temp,
+              system,
+              messages: [
+                { role: "user", content: prompt },
+              ],
+            }),
+          catch: mapClaudeError,
+        }).pipe(
+          Effect.map((response): LlmResult => {
+            const firstContent = response.content[0];
+            const text = firstContent?.type === "text"
+              ? firstContent.text
+              : "";
 
-        const text = response.content[0].type === "text"
-          ? response.content[0].text
-          : "";
-
-        return {
-          text,
-          inToken: response.usage.input_tokens,
-          outToken: response.usage.output_tokens,
-          model: modelName,
-        };
-      } catch (err) {
-        if (err instanceof Anthropic.RateLimitError) {
-          throw tooManyRequestsError();
-        }
-        throw err;
-      }
+            return {
+              text,
+              inToken: response.usage.input_tokens,
+              outToken: response.usage.output_tokens,
+              model: modelName,
+            };
+          }),
+        ),
+      );
     },
     supportsStreaming: () => true,
-    generateContentStream: async function* (
+    generateContentStream: (
       system: string,
       prompt: string,
       model?: string,
       temperature?: number,
-    ): AsyncGenerator<LlmChunk> {
+    ): AsyncGenerator<LlmChunk> => {
       const modelName = model ?? defaultModel;
       const temp = temperature ?? defaultTemperature;
 
-      try {
-        const stream = client.messages.stream({
-          model: modelName,
-          max_tokens: maxOutput,
-          temperature: temp,
-          system,
-          messages: [
-            { role: "user", content: prompt },
-          ],
-        });
-
-        for await (const event of stream) {
-          if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
-            yield {
-              text: event.delta.text,
-              inToken: null,
-              outToken: null,
+      const stream = Stream.fromEffect(
+        Effect.try({
+          try: () =>
+            client.messages.stream({
               model: modelName,
-              isFinal: false,
-            };
-          }
-        }
+              max_tokens: maxOutput,
+              temperature: temp,
+              system,
+              messages: [
+                { role: "user", content: prompt },
+              ],
+            }),
+          catch: mapClaudeError,
+        }),
+      ).pipe(
+        Stream.flatMap((anthropicStream) => {
+          const iterator = anthropicStream[Symbol.asyncIterator]();
 
-        const finalMessage = await stream.finalMessage();
-        yield {
-          text: "",
-          inToken: finalMessage.usage.input_tokens,
-          outToken: finalMessage.usage.output_tokens,
-          model: modelName,
-          isFinal: true,
-        };
-      } catch (err) {
-        if (err instanceof Anthropic.RateLimitError) {
-          throw tooManyRequestsError();
-        }
-        throw err;
-      }
+          return Stream.unfold<"pulling" | "done", LlmChunk, TextCompletionRuntimeError, never>(
+            "pulling",
+            (state) => {
+              if (state === "done") return Effect.void as Effect.Effect<undefined>;
+
+              return Effect.gen(function* () {
+                while (true) {
+                  const next = yield* Effect.tryPromise({
+                    try: () => iterator.next(),
+                    catch: mapClaudeError,
+                  });
+
+                  if (next.done === true) {
+                    const finalMessage = yield* Effect.tryPromise({
+                      try: () => anthropicStream.finalMessage(),
+                      catch: mapClaudeError,
+                    });
+                    return [{
+                      text: "",
+                      inToken: finalMessage.usage.input_tokens,
+                      outToken: finalMessage.usage.output_tokens,
+                      model: modelName,
+                      isFinal: true,
+                    }, "done"] as const;
+                  }
+
+                  const event = next.value;
+                  if (
+                    event.type === "content_block_delta" &&
+                    event.delta.type === "text_delta"
+                  ) {
+                    return [{
+                      text: event.delta.text,
+                      inToken: null,
+                      outToken: null,
+                      model: modelName,
+                      isFinal: false,
+                    }, "pulling"] as const;
+                  }
+                }
+              });
+            },
+          );
+        }),
+      );
+
+      return toAsyncGenerator(Stream.toAsyncIterable(stream), mapClaudeError);
     },
   };
 }
 
 export type ClaudeProcessor = ReturnType<typeof makeClaudeProcessor>;
 
-export function makeClaudeProcessor(config: ClaudeProcessorConfig): ReturnType<typeof makeLlmService> {
+export function makeClaudeProcessor(
+  config: ClaudeProcessorConfig,
+): ReturnType<typeof makeLlmService> {
   return makeLlmService(config, makeClaudeProvider(config));
 }
 
@@ -146,6 +209,6 @@ export const program = makeFlowProcessorProgram<ProcessorConfig, never, Llm>({
     ),
 });
 
-export async function run(): Promise<void> {
-  await Effect.runPromise(program);
+export function run(): Promise<void> {
+  return Effect.runPromise(program);
 }