ai-functions 2.1.3 → 2.4.0

package/src/generate.ts

@@ -10,18 +10,15 @@
  */
 
 import {
-  generateObject as sdkGenerateObject,
   generateText as sdkGenerateText,
-  streamObject as sdkStreamObject,
   streamText as sdkStreamText,
-  type GenerateObjectResult,
+  Output,
   type GenerateTextResult,
-  type StreamObjectResult,
   type StreamTextResult,
-  type LanguageModel
+  type LanguageModel,
 } from 'ai'
 import { schema as convertSchema, type SimpleSchema } from './schema.js'
-import { isZodSchema } from '@org.ai/core'
+import { isZodSchema } from './type-guards.js'
 import type { ZodTypeAny } from 'zod'
 
 type ModelArg = string | LanguageModel
@@ -44,7 +41,11 @@ interface GenerateObjectOptions<T> {
   maxRetries?: number
   abortSignal?: AbortSignal
   headers?: Record<string, string>
-  experimental_telemetry?: { isEnabled?: boolean; functionId?: string; metadata?: Record<string, string> }
+  experimental_telemetry?: {
+    isEnabled?: boolean
+    functionId?: string
+    metadata?: Record<string, string>
+  }
 }
 
 interface GenerateTextOptions {
@@ -65,7 +66,11 @@ interface GenerateTextOptions {
   tools?: Record<string, unknown>
   toolChoice?: 'auto' | 'none' | 'required' | { type: 'tool'; toolName: string }
   maxSteps?: number
-  experimental_telemetry?: { isEnabled?: boolean; functionId?: string; metadata?: Record<string, string> }
+  experimental_telemetry?: {
+    isEnabled?: boolean
+    functionId?: string
+    metadata?: Record<string, string>
+  }
 }
 
 /**
@@ -131,16 +136,17 @@ function resolveSchema(schemaArg: SchemaArg): ZodTypeAny {
  */
 export async function generateObject<T>(
   options: GenerateObjectOptions<T>
-): Promise<GenerateObjectResult<T>> {
+): Promise<{ object: T; usage?: unknown; warnings?: unknown[] | undefined }> {
   const model = await resolveModel(options.model)
   const schema = resolveSchema(options.schema as SchemaArg)
-  // Use 'as any' to handle AI SDK v4 API variance
-  return sdkGenerateObject({
-    ...options,
+  const { schema: _schema, mode: _mode, ...rest } = options
+  // Using unknown cast for SDK compatibility - the AI SDK has complex type unions
+  const result = await sdkGenerateText({
+    ...rest,
     model,
-    schema,
-    output: 'object'
-  } as any) as Promise<GenerateObjectResult<T>>
+    output: Output.object({ schema }),
+  } as unknown as Parameters<typeof sdkGenerateText>[0])
+  return { object: result.output as T, usage: result.usage, warnings: result.warnings }
 }
 
 /**
@@ -172,7 +178,7 @@ export async function generateText(
   const model = await resolveModel(options.model)
   return sdkGenerateText({
     ...options,
-    model
+    model,
   } as Parameters<typeof sdkGenerateText>[0])
 }
 
@@ -196,20 +202,19 @@ export async function generateText(
  */
 export async function streamObject<T>(
   options: GenerateObjectOptions<T>
-): Promise<StreamObjectResult<T, T, never>> {
+): Promise<{ partialObjectStream: AsyncIterable<T> }> {
   const model = await resolveModel(options.model)
   const schema = resolveSchema(options.schema as SchemaArg)
-  // NOTE: Type assertion required due to AI SDK's complex conditional return types.
-  // The SDK uses different return types based on output mode ('object' | 'array' | 'enum' | 'no-schema')
-  // and schema definition presence. Our wrapper simplifies this to always use 'object' output mode.
-  // This cast is safe because we control the input parameters.
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return sdkStreamObject({
-    ...options,
+  const { schema: _schema, mode: _mode, ...rest } = options
+  // Using unknown cast for SDK compatibility - the AI SDK has complex type unions
+  const result = await sdkStreamText({
+    ...rest,
     model,
-    schema,
-    output: 'object'
-  } as any) as StreamObjectResult<T, T, never>
+    output: Output.object({ schema }),
+  } as unknown as Parameters<typeof sdkStreamText>[0])
+  return {
+    partialObjectStream: result.partialOutputStream as AsyncIterable<T>,
+  }
 }
 
 /**
@@ -235,6 +240,6 @@ export async function streamText(
   const model = await resolveModel(options.model)
   return sdkStreamText({
     ...options,
-    model
+    model,
   } as Parameters<typeof sdkStreamText>[0])
 }

package/src/index.ts

@@ -17,10 +17,10 @@
  */
 
 // ============================================================================
-// Re-export core primitives from ai-core for backward compatibility
+// Re-export core primitives for backward compatibility
 // ============================================================================
 
-// Types from ai-core
+// Types
 export type {
   AIFunctionDefinition,
   JSONSchema,
@@ -46,6 +46,7 @@ export type {
   BaseFunctionDefinition,
   CodeFunctionDefinition,
   CodeFunctionResult,
+  CodeGenerationDefinition,
   GenerativeFunctionDefinition,
   GenerativeFunctionResult,
   AgenticFunctionDefinition,
@@ -56,12 +57,13 @@ export type {
   DefinedFunction,
   FunctionRegistry,
   AutoDefineResult,
-} from '@org.ai/core'
+  SandboxEnv,
+} from './types.js'
 
-// Schema exports from ai-core
-export { schema, type SimpleSchema } from '@org.ai/core'
+// Schema exports
+export { schema, type SimpleSchema } from './schema.js'
 
-// Template exports from ai-core
+// Template exports
 export {
   parseTemplate,
   createTemplateFunction,
@@ -73,9 +75,9 @@ export {
   type BatchableFunction,
   type StreamableList,
   type ChainablePromise,
-} from '@org.ai/core'
+} from './template.js'
 
-// AIPromise exports from ai-core
+// AIPromise exports
 export {
   AIPromise,
   isAIPromise,
@@ -93,12 +95,12 @@ export {
   type AIPromiseOptions,
   type StreamingAIPromise,
   type StreamOptions,
-} from '@org.ai/core'
+} from './ai-promise.js'
 
-// Generation exports from ai-core
-export { generateObject, generateText, streamObject, streamText } from '@org.ai/core'
+// Generation exports
+export { generateObject, generateText, streamObject, streamText } from './generate.js'
 
-// Primitives from ai-core
+// Primitives
 export {
   generate,
   type GenerateType,
@@ -125,9 +127,9 @@ export {
   review,
   type HumanOptions,
   type HumanResult,
-} from '@org.ai/core'
+} from './primitives.js'
 
-// Context exports from ai-core (basic version)
+// Context exports
 export {
   configure,
   getContext,
@@ -137,20 +139,41 @@ export {
   getModel,
   getProvider,
   type ExecutionContext,
-} from '@org.ai/core'
+} from './context.js'
 
-// Type guards from ai-core
-export { isZodSchema } from '@org.ai/core'
+// Type guards
+export { isZodSchema } from './type-guards.js'
 
 // ============================================================================
 // Export AI Proxy (the AI class/proxy from ai.ts)
 // This is separate from the core 'ai' template function
 // ============================================================================
 
-export { AI, define, defineFunction, type AIProxy } from './ai.js'
-
-// Also export 'ai' primitive as 'aiPrompt' to avoid conflict with AIProxy
-export { ai as aiPrompt } from '@org.ai/core'
+export {
+  AI,
+  ai as aiProxy,
+  define,
+  defineFunction,
+  functions,
+  createFunctionRegistry,
+  resetGlobalRegistry,
+  withTemplate,
+  type AIProxy,
+  // Also export from new split modules
+  createSchemaFunctions,
+  type AISchemaOptions,
+  type SchemaFunctions,
+  type InferSimpleSchemaResult,
+  createDefinedFunction,
+  convertArgsToJSONSchema,
+  fillTemplate,
+  generateCode,
+  generateAndRunCode,
+  type GeneratedCodeRunResult,
+} from './ai.js'
+
+// Also export 'ai' primitive as 'aiPrompt' for convenience
+export { ai as aiPrompt } from './primitives.js'
 
 // Export embedding utilities (not in ai-core)
 export * from './embeddings.js'
@@ -169,6 +192,11 @@ export {
   withBatch as withBatchQueue,
   registerBatchAdapter,
   getBatchAdapter,
+  registerFlexAdapter,
+  getFlexAdapter,
+  hasFlexAdapter,
+  tiersForModel,
+  modelSupportsTier,
   isBatchMode,
   deferToBatch,
   BATCH_MODE_SYMBOL,
@@ -180,10 +208,21 @@ export {
   type BatchResult,
   type BatchSubmitResult,
   type BatchAdapter,
+  type FlexAdapter,
   type BatchQueueOptions,
   type DeferredOptions,
 } from './batch-queue.js'
 
+// Export per-model policy data (sourced from language-models)
+export {
+  policyFor as modelPolicyFor,
+  type ModelPolicy,
+  type BatchTier,
+  type RetryPolicyData,
+  type CircuitBreakerPolicyData,
+  type ErrorCategoryName,
+} from 'language-models'
+
 // Export batch map for automatic batching
 export {
   BatchMapPromise,
@@ -330,3 +369,65 @@ export {
   type FallbackOptions,
   type FallbackMetrics,
 } from './retry.js'
+
+// Export digital-objects function registry
+export {
+  DigitalObjectsFunctionRegistry,
+  createDigitalObjectsRegistry,
+  FUNCTION_NOUNS,
+  FUNCTION_VERBS,
+  type StoredFunctionDefinition,
+  type FunctionCallData,
+  type DigitalObjectsRegistryOptions,
+} from './digital-objects-registry.js'
+
+// Export configurable logger
+export {
+  configureLogger,
+  getLogger,
+  resetLogger,
+  getLogLevel,
+  setLogLevel,
+  type Logger,
+  type LoggerConfig,
+} from './logger.js'
+
+// ============================================================================
+// V3 middleware stack — cache / budget / trace via wrapLanguageModel
+// ============================================================================
+
+// Composable middleware primitives
+export {
+  cacheMiddleware,
+  embeddingCacheMiddleware,
+  budgetMiddleware,
+  traceMiddleware,
+  type CacheMiddlewareOptions,
+  type CacheMiddlewareStore,
+  type EmbedCacheMiddlewareOptions,
+  type EmbedCacheMiddlewareStore,
+  type BudgetMiddlewareOptions,
+  type PricingOverlay,
+  type TraceEvent,
+  type TraceEventKind,
+  type TraceMiddlewareOptions,
+} from './middleware/index.js'
+
+// Convenience composer
+export { wrapForV3, type WrapForV3Options } from './wrap-for-v3.js'
+
+// Type re-export — downstream packages (services-as-software EvaluatorPanel
+// model-injection point, etc.) need `LanguageModelV3` for typing wrapped-model
+// arguments. Re-exporting from ai-functions avoids forcing every consumer to
+// depend on `@ai-sdk/provider` directly.
+export type { LanguageModelV3 } from '@ai-sdk/provider'
+
+// Pluggable persistence primitive for trace/eval entries
+export {
+  InMemoryEvalLogStore,
+  getEvalLogStore,
+  configureEvalLogStore,
+  type EvalLogEntry,
+  type EvalLogListOptions,
+  type EvalLogStore,
+} from './eval-log/index.js'

package/src/logger.ts

@@ -0,0 +1,232 @@
+/**
+ * Configurable Logger for AI Functions
+ *
+ * Provides a pluggable logging interface that defaults to console but can be
+ * configured to use any logging implementation. This allows library consumers
+ * to integrate with their own logging infrastructure.
+ *
+ * @example
+ * ```ts
+ * import { configureLogger, getLogger } from 'ai-functions'
+ *
+ * // Use with default console logger
+ * const logger = getLogger()
+ * logger.warn('Something happened')
+ *
+ * // Configure a custom logger
+ * configureLogger({
+ *   debug: (msg, ...args) => myLogger.debug(msg, ...args),
+ *   info: (msg, ...args) => myLogger.info(msg, ...args),
+ *   warn: (msg, ...args) => myLogger.warn(msg, ...args),
+ *   error: (msg, ...args) => myLogger.error(msg, ...args),
+ * })
+ *
+ * // Disable logging entirely
+ * configureLogger(null)
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+// ============================================================================
+// Logger Interface
+// ============================================================================
+
+/**
+ * Logger interface that matches the standard console methods.
+ *
+ * All methods are optional to allow partial implementations.
+ * Missing methods will be no-ops when called.
+ */
+export interface Logger {
+  /** Debug level logging (verbose) */
+  debug?: (message: string, ...args: unknown[]) => void
+  /** Info level logging (general information) */
+  info?: (message: string, ...args: unknown[]) => void
+  /** Warning level logging (potential issues) */
+  warn?: (message: string, ...args: unknown[]) => void
+  /** Error level logging (errors and exceptions) */
+  error?: (message: string, ...args: unknown[]) => void
+}
+
+/**
+ * Logger configuration options
+ */
+export interface LoggerConfig {
+  /** The logger implementation to use */
+  logger?: Logger | null
+  /** Minimum log level to output */
+  level?: 'debug' | 'info' | 'warn' | 'error' | 'silent'
+}
+
+// ============================================================================
+// Logger State
+// ============================================================================
+
+/** Log level priority (lower = more verbose) */
+const LOG_LEVELS: Record<string, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4,
+}
+
+/** Default console-based logger */
+const defaultLogger: Logger = {
+  debug: (message: string, ...args: unknown[]) => console.debug(message, ...args),
+  info: (message: string, ...args: unknown[]) => console.info(message, ...args),
+  warn: (message: string, ...args: unknown[]) => console.warn(message, ...args),
+  error: (message: string, ...args: unknown[]) => console.error(message, ...args),
+}
+
+/** No-op logger for when logging is disabled */
+const noopLogger: Logger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+}
+
+/** Current logger instance */
+let currentLogger: Logger = defaultLogger
+
+/** Current minimum log level */
+let currentLevel: string = 'warn'
+
+// ============================================================================
+// Configuration Functions
+// ============================================================================
+
+/**
+ * Configure the global logger for ai-functions.
+ *
+ * @param config - Logger configuration or just a logger instance
+ *
+ * @example
+ * ```ts
+ * // Use a custom logger
+ * configureLogger({
+ *   logger: {
+ *     debug: (msg) => myLogger.debug(msg),
+ *     info: (msg) => myLogger.info(msg),
+ *     warn: (msg) => myLogger.warn(msg),
+ *     error: (msg) => myLogger.error(msg),
+ *   },
+ *   level: 'info',
+ * })
+ *
+ * // Just set the log level
+ * configureLogger({ level: 'debug' })
+ *
+ * // Disable all logging
+ * configureLogger({ logger: null })
+ * // or
+ * configureLogger({ level: 'silent' })
+ *
+ * // Reset to defaults
+ * configureLogger({})
+ * ```
+ */
+export function configureLogger(config: LoggerConfig | Logger | null): void {
+  // Handle null (disable logging)
+  if (config === null) {
+    currentLogger = noopLogger
+    return
+  }
+
+  // Handle Logger directly
+  if (config && ('debug' in config || 'info' in config || 'warn' in config || 'error' in config)) {
+    // Check if it's a Logger (has at least one log method but no 'logger' or 'level' key)
+    if (!('logger' in config) && !('level' in config)) {
+      currentLogger = config as Logger
+      return
+    }
+  }
+
+  // Handle LoggerConfig
+  const loggerConfig = config as LoggerConfig
+
+  if (loggerConfig.logger === null) {
+    currentLogger = noopLogger
+  } else if (loggerConfig.logger) {
+    currentLogger = loggerConfig.logger
+  } else if (config === undefined || Object.keys(config as object).length === 0) {
+    // Reset to default
+    currentLogger = defaultLogger
+    currentLevel = 'warn'
+    return
+  }
+
+  if (loggerConfig.level) {
+    currentLevel = loggerConfig.level
+  }
+}
+
+/**
+ * Get the current logger instance.
+ *
+ * Returns a logger that respects the configured log level.
+ * Methods for levels below the configured minimum will be no-ops.
+ *
+ * @returns Logger instance with level filtering applied
+ *
+ * @example
+ * ```ts
+ * const logger = getLogger()
+ * logger.warn('This is a warning')
+ * logger.error('This is an error', { details: 'foo' })
+ * ```
+ */
+export function getLogger(): Required<Logger> {
+  const minLevel = LOG_LEVELS[currentLevel] ?? LOG_LEVELS['warn']!
+
+  return {
+    debug: (message: string, ...args: unknown[]) => {
+      if (minLevel <= LOG_LEVELS['debug']!) {
+        currentLogger.debug?.(message, ...args)
+      }
+    },
+    info: (message: string, ...args: unknown[]) => {
+      if (minLevel <= LOG_LEVELS['info']!) {
+        currentLogger.info?.(message, ...args)
+      }
+    },
+    warn: (message: string, ...args: unknown[]) => {
+      if (minLevel <= LOG_LEVELS['warn']!) {
+        currentLogger.warn?.(message, ...args)
+      }
+    },
+    error: (message: string, ...args: unknown[]) => {
+      if (minLevel <= LOG_LEVELS['error']!) {
+        currentLogger.error?.(message, ...args)
+      }
+    },
+  }
+}
+
+/**
+ * Reset the logger to default configuration.
+ *
+ * Restores the console-based logger with 'warn' minimum level.
+ */
+export function resetLogger(): void {
+  currentLogger = defaultLogger
+  currentLevel = 'warn'
+}
+
+/**
+ * Get the current log level
+ */
+export function getLogLevel(): string {
+  return currentLevel
+}
+
+/**
+ * Set the minimum log level
+ *
+ * @param level - Minimum level to log ('debug' | 'info' | 'warn' | 'error' | 'silent')
+ */
+export function setLogLevel(level: 'debug' | 'info' | 'warn' | 'error' | 'silent'): void {
+  currentLevel = level
+}