libretto 0.5.0 → 0.5.2

package/src/shared/llm/ai-sdk-adapter.ts

@@ -18,61 +18,64 @@ import type { LLMClient, Message } from "./types.js";
  * ```
  */
 export function createLLMClientFromModel(model: LanguageModel): LLMClient {
-	return {
-		async generateObject<T extends ZodType>(opts: {
-			prompt: string;
-			schema: T;
-			temperature?: number;
-		}): Promise<ZodOutput<T>> {
-			const { object } = await generateObject({
-				model,
-				schema: opts.schema,
-				prompt: opts.prompt,
-				temperature: opts.temperature ?? 0,
-			});
-			return object as ZodOutput<T>;
-		},
+  return {
+    async generateObject<T extends ZodType>(opts: {
+      prompt: string;
+      schema: T;
+      temperature?: number;
+    }): Promise<ZodOutput<T>> {
+      const { object } = await generateObject({
+        model,
+        schema: opts.schema,
+        prompt: opts.prompt,
+        temperature: opts.temperature ?? 0,
+      });
+      return object as ZodOutput<T>;
+    },
 
-		async generateObjectFromMessages<T extends ZodType>(opts: {
-			messages: Message[];
-			schema: T;
-			temperature?: number;
-		}): Promise<ZodOutput<T>> {
-			// Convert libretto Message format to AI SDK message format
-			const messages = opts.messages.map((msg) => {
-				if (typeof msg.content === "string") {
-					return { role: msg.role, content: msg.content };
-				}
-				if (msg.role === "assistant") {
-					// AssistantContent only supports text parts (no images)
-					return {
-						role: "assistant" as const,
-						content: msg.content
-							.filter((part): part is typeof part & { type: "text" } => part.type === "text")
-							.map((part) => ({ type: "text" as const, text: part.text })),
-					};
-				}
-				return {
-					role: "user" as const,
-					content: msg.content.map((part) =>
-						part.type === "text"
-							? { type: "text" as const, text: part.text }
-							: {
-								type: "image" as const,
-								image: part.image,
-								...(part.mediaType ? { mediaType: part.mediaType } : {}),
-							},
-					),
-				};
-			});
+    async generateObjectFromMessages<T extends ZodType>(opts: {
+      messages: Message[];
+      schema: T;
+      temperature?: number;
+    }): Promise<ZodOutput<T>> {
+      // Convert libretto Message format to AI SDK message format
+      const messages = opts.messages.map((msg) => {
+        if (typeof msg.content === "string") {
+          return { role: msg.role, content: msg.content };
+        }
+        if (msg.role === "assistant") {
+          // AssistantContent only supports text parts (no images)
+          return {
+            role: "assistant" as const,
+            content: msg.content
+              .filter(
+                (part): part is typeof part & { type: "text" } =>
+                  part.type === "text",
+              )
+              .map((part) => ({ type: "text" as const, text: part.text })),
+          };
+        }
+        return {
+          role: "user" as const,
+          content: msg.content.map((part) =>
+            part.type === "text"
+              ? { type: "text" as const, text: part.text }
+              : {
+                  type: "image" as const,
+                  image: part.image,
+                  ...(part.mediaType ? { mediaType: part.mediaType } : {}),
+                },
+          ),
+        };
+      });
 
-			const { object } = await generateObject({
-				model,
-				schema: opts.schema,
-				messages,
-				temperature: opts.temperature ?? 0,
-			});
-			return object as ZodOutput<T>;
-		},
-	};
+      const { object } = await generateObject({
+        model,
+        schema: opts.schema,
+        messages,
+        temperature: opts.temperature ?? 0,
+      });
+      return object as ZodOutput<T>;
+    },
+  };
 }

package/src/shared/llm/client.ts

@@ -5,213 +5,220 @@ import type { LLMClient, Message, MessageContentPart } from "./types.js";
 export type Provider = "google" | "vertex" | "anthropic" | "openai";
 
 const GEMINI_API_KEY_ENV_VARS = [
-	"GEMINI_API_KEY",
-	"GOOGLE_GENERATIVE_AI_API_KEY",
+  "GEMINI_API_KEY",
+  "GOOGLE_GENERATIVE_AI_API_KEY",
 ] as const;
 
 const VERTEX_PROJECT_ENV_VARS = [
-	"GOOGLE_CLOUD_PROJECT",
-	"GCLOUD_PROJECT",
+  "GOOGLE_CLOUD_PROJECT",
+  "GCLOUD_PROJECT",
 ] as const;
 
 const SUPPORTED_PROVIDER_ALIASES = {
-	google: "google",
-	gemini: "google",
-	vertex: "vertex",
-	anthropic: "anthropic",
-	codex: "openai",
-	openai: "openai",
+  google: "google",
+  gemini: "google",
+  vertex: "vertex",
+  anthropic: "anthropic",
+  codex: "openai",
+  openai: "openai",
 } as const satisfies Record<string, Provider>;
 
 function readFirstEnvValue(
-	env: NodeJS.ProcessEnv,
-	names: readonly string[],
+  env: NodeJS.ProcessEnv,
+  names: readonly string[],
 ): string | null {
-	for (const name of names) {
-		const value = env[name]?.trim();
-		if (value) return value;
-	}
-	return null;
+  for (const name of names) {
+    const value = env[name]?.trim();
+    if (value) return value;
+  }
+  return null;
 }
 
-export function parseModel(model: string): { provider: Provider; modelId: string } {
-	const slashIndex = model.indexOf("/");
-	if (slashIndex === -1) {
-		throw new Error(
-			`Invalid model string "${model}". Expected format: "provider/model-id" (for example "openai/gpt-5.4", "anthropic/claude-sonnet-4-6", "google/gemini-3-flash-preview", or "vertex/gemini-2.5-pro").`,
-		);
-	}
-	const providerInput = model.slice(0, slashIndex).toLowerCase();
-	const provider = SUPPORTED_PROVIDER_ALIASES[
-		providerInput as keyof typeof SUPPORTED_PROVIDER_ALIASES
-	];
-	const modelId = model.slice(slashIndex + 1);
-
-	if (!provider) {
-		throw new Error(
-			`Unsupported provider "${providerInput}". Supported providers: openai/codex, anthropic, google (Gemini API), and vertex.`,
-		);
-	}
-
-	return { provider, modelId };
+export function parseModel(model: string): {
+  provider: Provider;
+  modelId: string;
+} {
+  const slashIndex = model.indexOf("/");
+  if (slashIndex === -1) {
+    throw new Error(
+      `Invalid model string "${model}". Expected format: "provider/model-id" (for example "openai/gpt-5.4", "anthropic/claude-sonnet-4-6", "google/gemini-3-flash-preview", or "vertex/gemini-2.5-pro").`,
+    );
+  }
+  const providerInput = model.slice(0, slashIndex).toLowerCase();
+  const provider =
+    SUPPORTED_PROVIDER_ALIASES[
+      providerInput as keyof typeof SUPPORTED_PROVIDER_ALIASES
+    ];
+  const modelId = model.slice(slashIndex + 1);
+
+  if (!provider) {
+    throw new Error(
+      `Unsupported provider "${providerInput}". Supported providers: openai/codex, anthropic, google (Gemini API), and vertex.`,
+    );
+  }
+
+  return { provider, modelId };
 }
 
 export function hasProviderCredentials(
-	provider: Provider,
-	env: NodeJS.ProcessEnv = process.env,
+  provider: Provider,
+  env: NodeJS.ProcessEnv = process.env,
 ): boolean {
-	switch (provider) {
-		case "google":
-			return readFirstEnvValue(env, GEMINI_API_KEY_ENV_VARS) !== null;
-		case "vertex":
-			return readFirstEnvValue(env, VERTEX_PROJECT_ENV_VARS) !== null;
-		case "anthropic":
-			return Boolean(env.ANTHROPIC_API_KEY?.trim());
-		case "openai":
-			return Boolean(env.OPENAI_API_KEY?.trim());
-	}
+  switch (provider) {
+    case "google":
+      return readFirstEnvValue(env, GEMINI_API_KEY_ENV_VARS) !== null;
+    case "vertex":
+      return readFirstEnvValue(env, VERTEX_PROJECT_ENV_VARS) !== null;
+    case "anthropic":
+      return Boolean(env.ANTHROPIC_API_KEY?.trim());
+    case "openai":
+      return Boolean(env.OPENAI_API_KEY?.trim());
+  }
 }
 
 export function missingProviderCredentialsMessage(provider: Provider): string {
-	switch (provider) {
-		case "google":
-			return "Gemini API key is missing. Set GEMINI_API_KEY or GOOGLE_GENERATIVE_AI_API_KEY.";
-		case "vertex":
-			return "Vertex AI project is missing. Set GOOGLE_CLOUD_PROJECT (or GCLOUD_PROJECT) and ensure application default credentials are configured.";
-		case "anthropic": {
-			return "Anthropic API key is missing. Set ANTHROPIC_API_KEY.";
-		}
-		case "openai": {
-			return "OpenAI API key is missing. Set OPENAI_API_KEY.";
-		}
-	}
+  switch (provider) {
+    case "google":
+      return "Gemini API key is missing. Set GEMINI_API_KEY or GOOGLE_GENERATIVE_AI_API_KEY.";
+    case "vertex":
+      return "Vertex AI project is missing. Set GOOGLE_CLOUD_PROJECT (or GCLOUD_PROJECT) and ensure application default credentials are configured.";
+    case "anthropic": {
+      return "Anthropic API key is missing. Set ANTHROPIC_API_KEY.";
+    }
+    case "openai": {
+      return "OpenAI API key is missing. Set OPENAI_API_KEY.";
+    }
+  }
 }
 
 async function getProviderModel(
-	provider: Provider,
-	modelId: string,
+  provider: Provider,
+  modelId: string,
 ): Promise<LanguageModel> {
-	switch (provider) {
-		case "google": {
-			const apiKey = readFirstEnvValue(process.env, GEMINI_API_KEY_ENV_VARS);
-			if (!apiKey) {
-				throw new Error(missingProviderCredentialsMessage(provider));
-			}
-			const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
-			const google = createGoogleGenerativeAI({ apiKey });
-			return google(modelId);
-		}
-		case "vertex": {
-			const project = readFirstEnvValue(process.env, VERTEX_PROJECT_ENV_VARS);
-			if (!project) {
-				throw new Error(missingProviderCredentialsMessage(provider));
-			}
-			const { createVertex } = await import("@ai-sdk/google-vertex");
-			const vertex = createVertex({
-				project,
-				location: process.env.GOOGLE_CLOUD_LOCATION || "global",
-			});
-			return vertex(modelId);
-		}
-		case "anthropic": {
-			const apiKey = process.env.ANTHROPIC_API_KEY?.trim();
-			if (!apiKey) {
-				throw new Error(missingProviderCredentialsMessage(provider));
-			}
-			const { createAnthropic } = await import("@ai-sdk/anthropic");
-			const anthropic = createAnthropic({ apiKey });
-			return anthropic(modelId);
-		}
-		case "openai": {
-			const apiKey = process.env.OPENAI_API_KEY?.trim();
-			if (!apiKey) {
-				throw new Error(missingProviderCredentialsMessage(provider));
-			}
-			const { createOpenAI } = await import("@ai-sdk/openai");
-			const openai = createOpenAI({ apiKey });
-			return openai(modelId);
-		}
-	}
+  switch (provider) {
+    case "google": {
+      const apiKey = readFirstEnvValue(process.env, GEMINI_API_KEY_ENV_VARS);
+      if (!apiKey) {
+        throw new Error(missingProviderCredentialsMessage(provider));
+      }
+      const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
+      const google = createGoogleGenerativeAI({ apiKey });
+      return google(modelId);
+    }
+    case "vertex": {
+      const project = readFirstEnvValue(process.env, VERTEX_PROJECT_ENV_VARS);
+      if (!project) {
+        throw new Error(missingProviderCredentialsMessage(provider));
+      }
+      const { createVertex } = await import("@ai-sdk/google-vertex");
+      const vertex = createVertex({
+        project,
+        location: process.env.GOOGLE_CLOUD_LOCATION || "global",
+      });
+      return vertex(modelId);
+    }
+    case "anthropic": {
+      const apiKey = process.env.ANTHROPIC_API_KEY?.trim();
+      if (!apiKey) {
+        throw new Error(missingProviderCredentialsMessage(provider));
+      }
+      const { createAnthropic } = await import("@ai-sdk/anthropic");
+      const anthropic = createAnthropic({ apiKey });
+      return anthropic(modelId);
+    }
+    case "openai": {
+      const apiKey = process.env.OPENAI_API_KEY?.trim();
+      if (!apiKey) {
+        throw new Error(missingProviderCredentialsMessage(provider));
+      }
+      const { createOpenAI } = await import("@ai-sdk/openai");
+      const openai = createOpenAI({ apiKey });
+      return openai(modelId);
+    }
+  }
 }
 
 function convertUserContentParts(parts: MessageContentPart[]) {
-	return parts.map((part) => {
-		if (part.type === "text") {
-			return { type: "text" as const, text: part.text };
-		}
-		return {
-			type: "image" as const,
-			image: part.image,
-			...(part.mediaType ? { mediaType: part.mediaType } : {}),
-		};
-	});
+  return parts.map((part) => {
+    if (part.type === "text") {
+      return { type: "text" as const, text: part.text };
+    }
+    return {
+      type: "image" as const,
+      image: part.image,
+      ...(part.mediaType ? { mediaType: part.mediaType } : {}),
+    };
+  });
 }
 
 function convertAssistantContentParts(parts: MessageContentPart[]) {
-	return parts
-		.filter((part): part is MessageContentPart & { type: "text" } => part.type === "text")
-		.map((part) => ({ type: "text" as const, text: part.text }));
+  return parts
+    .filter(
+      (part): part is MessageContentPart & { type: "text" } =>
+        part.type === "text",
+    )
+    .map((part) => ({ type: "text" as const, text: part.text }));
 }
 
 function convertMessages(messages: Message[]): ModelMessage[] {
-	return messages.map((msg): ModelMessage => {
-		if (msg.role === "user") {
-			if (typeof msg.content === "string") {
-				return { role: "user", content: msg.content };
-			}
-			return {
-				role: "user",
-				content: convertUserContentParts(msg.content),
-			};
-		}
-		if (typeof msg.content === "string") {
-			return { role: "assistant", content: msg.content };
-		}
-		return {
-			role: "assistant",
-			content: convertAssistantContentParts(msg.content),
-		};
-	});
+  return messages.map((msg): ModelMessage => {
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        return { role: "user", content: msg.content };
+      }
+      return {
+        role: "user",
+        content: convertUserContentParts(msg.content),
+      };
+    }
+    if (typeof msg.content === "string") {
+      return { role: "assistant", content: msg.content };
+    }
+    return {
+      role: "assistant",
+      content: convertAssistantContentParts(msg.content),
+    };
+  });
 }
 
 export function createLLMClient(model: string): LLMClient {
-	const { provider, modelId } = parseModel(model);
-	let modelPromise: Promise<LanguageModel> | null = null;
-
-	const getModel = () => {
-		modelPromise ??= getProviderModel(provider, modelId);
-		return modelPromise;
-	};
-
-	return {
-		async generateObject<T extends ZodType>(opts: {
-			prompt: string;
-			schema: T;
-			temperature?: number;
-		}): Promise<ZodOutput<T>> {
-			const aiModel = await getModel();
-			const result = await generateObject({
-				model: aiModel,
-				prompt: opts.prompt,
-				schema: opts.schema,
-				temperature: opts.temperature ?? 0,
-			});
-			return result.object as ZodOutput<T>;
-		},
-
-		async generateObjectFromMessages<T extends ZodType>(opts: {
-			messages: Message[];
-			schema: T;
-			temperature?: number;
-		}): Promise<ZodOutput<T>> {
-			const aiModel = await getModel();
-			const result = await generateObject({
-				model: aiModel,
-				messages: convertMessages(opts.messages),
-				schema: opts.schema,
-				temperature: opts.temperature ?? 0,
-			});
-			return result.object as ZodOutput<T>;
-		},
-	};
+  const { provider, modelId } = parseModel(model);
+  let modelPromise: Promise<LanguageModel> | null = null;
+
+  const getModel = () => {
+    modelPromise ??= getProviderModel(provider, modelId);
+    return modelPromise;
+  };
+
+  return {
+    async generateObject<T extends ZodType>(opts: {
+      prompt: string;
+      schema: T;
+      temperature?: number;
+    }): Promise<ZodOutput<T>> {
+      const aiModel = await getModel();
+      const result = await generateObject({
+        model: aiModel,
+        prompt: opts.prompt,
+        schema: opts.schema,
+        temperature: opts.temperature ?? 0,
+      });
+      return result.object as ZodOutput<T>;
+    },
+
+    async generateObjectFromMessages<T extends ZodType>(opts: {
+      messages: Message[];
+      schema: T;
+      temperature?: number;
+    }): Promise<ZodOutput<T>> {
+      const aiModel = await getModel();
+      const result = await generateObject({
+        model: aiModel,
+        messages: convertMessages(opts.messages),
+        schema: opts.schema,
+        temperature: opts.temperature ?? 0,
+      });
+      return result.object as ZodOutput<T>;
+    },
+  };
 }

package/src/shared/llm/types.ts

@@ -1,12 +1,12 @@
 import type z from "zod";
 
 export type MessageContentPart =
-	| { type: "text"; text: string }
-	| { type: "image"; image: string | Uint8Array; mediaType?: string };
+  | { type: "text"; text: string }
+  | { type: "image"; image: string | Uint8Array; mediaType?: string };
 
 export type Message = {
-	role: "user" | "assistant";
-	content: string | MessageContentPart[];
+  role: "user" | "assistant";
+  content: string | MessageContentPart[];
 };
 
 /**
@@ -24,40 +24,40 @@ export type Message = {
  * {@link createLLMClientFromModel} in `libretto/llm`.
  */
 export interface LLMClient {
-	/**
-	 * Generate a structured object from a single text prompt.
-	 *
-	 * The underlying model **must** support structured / JSON output so that
-	 * the response can be parsed and validated against the provided Zod schema.
-	 *
-	 * @param opts.prompt - The text prompt sent to the model.
-	 * @param opts.schema - A Zod schema describing the expected response shape.
-	 * @param opts.temperature - Sampling temperature (default chosen by implementation, typically 0).
-	 * @returns The parsed object matching the schema.
-	 * @throws On LLM or parsing failure.
-	 */
-	generateObject<T extends z.ZodType>(opts: {
-		prompt: string;
-		schema: T;
-		temperature?: number;
-	}): Promise<z.output<T>>;
+  /**
+   * Generate a structured object from a single text prompt.
+   *
+   * The underlying model **must** support structured / JSON output so that
+   * the response can be parsed and validated against the provided Zod schema.
+   *
+   * @param opts.prompt - The text prompt sent to the model.
+   * @param opts.schema - A Zod schema describing the expected response shape.
+   * @param opts.temperature - Sampling temperature (default chosen by implementation, typically 0).
+   * @returns The parsed object matching the schema.
+   * @throws On LLM or parsing failure.
+   */
+  generateObject<T extends z.ZodType>(opts: {
+    prompt: string;
+    schema: T;
+    temperature?: number;
+  }): Promise<z.output<T>>;
 
-	/**
-	 * Generate a structured object from a conversation-style message array.
-	 *
-	 * Messages may contain **image content** (base64 data URIs via
-	 * {@link MessageContentPart}), so the backing model must support
-	 * vision / multimodal input when images are present.
-	 *
-	 * @param opts.messages - Ordered list of user/assistant messages, potentially multimodal.
-	 * @param opts.schema - A Zod schema describing the expected response shape.
-	 * @param opts.temperature - Sampling temperature (default chosen by implementation, typically 0).
-	 * @returns The parsed object matching the schema.
-	 * @throws On LLM or parsing failure.
-	 */
-	generateObjectFromMessages<T extends z.ZodType>(opts: {
-		messages: Message[];
-		schema: T;
-		temperature?: number;
-	}): Promise<z.output<T>>;
+  /**
+   * Generate a structured object from a conversation-style message array.
+   *
+   * Messages may contain **image content** (base64 data URIs via
+   * {@link MessageContentPart}), so the backing model must support
+   * vision / multimodal input when images are present.
+   *
+   * @param opts.messages - Ordered list of user/assistant messages, potentially multimodal.
+   * @param opts.schema - A Zod schema describing the expected response shape.
+   * @param opts.temperature - Sampling temperature (default chosen by implementation, typically 0).
+   * @returns The parsed object matching the schema.
+   * @throws On LLM or parsing failure.
+   */
+  generateObjectFromMessages<T extends z.ZodType>(opts: {
+    messages: Message[];
+    schema: T;
+    temperature?: number;
+  }): Promise<z.output<T>>;
 }

package/src/shared/logger/index.ts

@@ -1,6 +1,13 @@
-export { Logger, defaultLogger, type LoggerApi, type MinimalLogger, type LoggerSink, type LogOptions } from "./logger.js";
 export {
-	createFileLogSink,
-	prettyConsoleSink,
-	jsonlConsoleSink,
+  Logger,
+  defaultLogger,
+  type LoggerApi,
+  type MinimalLogger,
+  type LoggerSink,
+  type LogOptions,
+} from "./logger.js";
+export {
+  createFileLogSink,
+  prettyConsoleSink,
+  jsonlConsoleSink,
 } from "./sinks.js";