@providerprotocol/ai 0.0.11 → 0.0.12

package/src/types/messages.ts

@@ -1,205 +0,0 @@
-import { generateId } from '../utils/id.ts';
-import type {
-  ContentBlock,
-  TextBlock,
-  ImageBlock,
-  AudioBlock,
-  VideoBlock,
-  UserContent,
-  AssistantContent,
-} from './content.ts';
-import type { ToolCall, ToolResult } from './tool.ts';
-
-/**
- * Message type discriminator
- */
-export type MessageType = 'user' | 'assistant' | 'tool_result';
-
-/**
- * Provider-namespaced metadata
- * Each provider uses its own namespace
- */
-export interface MessageMetadata {
-  [provider: string]: Record<string, unknown> | undefined;
-}
-
-/**
- * Options for message construction
- */
-export interface MessageOptions {
-  id?: string;
-  metadata?: MessageMetadata;
-}
-
-/**
- * Base message class
- * All messages inherit from this
- */
-export abstract class Message {
-  /** Unique message identifier */
-  readonly id: string;
-
-  /** Timestamp */
-  readonly timestamp: Date;
-
-  /** Provider-specific metadata, namespaced by provider */
-  readonly metadata?: MessageMetadata;
-
-  /** Message type discriminator */
-  abstract readonly type: MessageType;
-
-  /** Raw content - implemented by subclasses */
-  protected abstract getContent(): ContentBlock[];
-
-  constructor(options?: MessageOptions) {
-    this.id = options?.id ?? generateId();
-    this.timestamp = new Date();
-    this.metadata = options?.metadata;
-  }
-
-  /**
-   * Convenience accessor for text content
-   * Concatenates all text blocks with '\n\n'
-   */
-  get text(): string {
-    return this.getContent()
-      .filter((block): block is TextBlock => block.type === 'text')
-      .map((block) => block.text)
-      .join('\n\n');
-  }
-
-  /**
-   * Convenience accessor for image content blocks
-   */
-  get images(): ImageBlock[] {
-    return this.getContent().filter((block): block is ImageBlock => block.type === 'image');
-  }
-
-  /**
-   * Convenience accessor for audio content blocks
-   */
-  get audio(): AudioBlock[] {
-    return this.getContent().filter((block): block is AudioBlock => block.type === 'audio');
-  }
-
-  /**
-   * Convenience accessor for video content blocks
-   */
-  get video(): VideoBlock[] {
-    return this.getContent().filter((block): block is VideoBlock => block.type === 'video');
-  }
-}
-
-/**
- * User input message
- */
-export class UserMessage extends Message {
-  readonly type = 'user' as const;
-  readonly content: UserContent[];
-
-  /**
-   * @param content - String (converted to TextBlock) or array of content blocks
-   */
-  constructor(content: string | UserContent[], options?: MessageOptions) {
-    super(options);
-    if (typeof content === 'string') {
-      this.content = [{ type: 'text', text: content }];
-    } else {
-      this.content = content;
-    }
-  }
-
-  protected getContent(): ContentBlock[] {
-    return this.content;
-  }
-}
-
-/**
- * Assistant response message
- * May contain text, media, and/or tool calls
- */
-export class AssistantMessage extends Message {
-  readonly type = 'assistant' as const;
-  readonly content: AssistantContent[];
-
-  /** Tool calls requested by the model (if any) */
-  readonly toolCalls?: ToolCall[];
-
-  /**
-   * @param content - String (converted to TextBlock) or array of content blocks
-   * @param toolCalls - Tool calls requested by the model
-   * @param options - Message ID and metadata
-   */
-  constructor(
-    content: string | AssistantContent[],
-    toolCalls?: ToolCall[],
-    options?: MessageOptions
-  ) {
-    super(options);
-    if (typeof content === 'string') {
-      this.content = [{ type: 'text', text: content }];
-    } else {
-      this.content = content;
-    }
-    this.toolCalls = toolCalls;
-  }
-
-  protected getContent(): ContentBlock[] {
-    return this.content;
-  }
-
-  /** Check if this message requests tool execution */
-  get hasToolCalls(): boolean {
-    return this.toolCalls !== undefined && this.toolCalls.length > 0;
-  }
-}
-
-/**
- * Result of tool execution (sent back to model)
- */
-export class ToolResultMessage extends Message {
-  readonly type = 'tool_result' as const;
-  readonly results: ToolResult[];
-
-  /**
-   * @param results - Array of tool execution results
-   * @param options - Message ID and metadata
-   */
-  constructor(results: ToolResult[], options?: MessageOptions) {
-    super(options);
-    this.results = results;
-  }
-
-  protected getContent(): ContentBlock[] {
-    // Tool results don't have traditional content blocks
-    // Return text representations of results
-    return this.results.map((result) => ({
-      type: 'text' as const,
-      text:
-        typeof result.result === 'string'
-          ? result.result
-          : JSON.stringify(result.result),
-    }));
-  }
-}
-
-/**
- * Type guard for UserMessage
- */
-export function isUserMessage(msg: Message): msg is UserMessage {
-  return msg.type === 'user';
-}
-
-/**
- * Type guard for AssistantMessage
- */
-export function isAssistantMessage(msg: Message): msg is AssistantMessage {
-  return msg.type === 'assistant';
-}
-
-/**
- * Type guard for ToolResultMessage
- */
-export function isToolResultMessage(msg: Message): msg is ToolResultMessage {
-  return msg.type === 'tool_result';
-}

package/src/types/provider.ts

@@ -1,195 +0,0 @@
-import type { UPPError } from './errors.ts';
-
-/**
- * API key strategy interface for managing multiple keys
- */
-export interface KeyStrategy {
-  /** Get the next API key to use */
-  getKey(): string | Promise<string>;
-}
-
-/**
- * Retry strategy interface
- */
-export interface RetryStrategy {
-  /**
-   * Called when a request fails with a retryable error.
-   * @param error - The error that occurred
-   * @param attempt - The attempt number (1 = first retry)
-   * @returns Delay in ms before retrying, or null to stop retrying
-   */
-  onRetry(error: UPPError, attempt: number): number | null | Promise<number | null>;
-
-  /**
-   * Called before each request. Can be used to implement pre-emptive rate limiting.
-   * Returns delay in ms to wait before making the request, or 0 to proceed immediately.
-   */
-  beforeRequest?(): number | Promise<number>;
-
-  /**
-   * Reset the strategy state (e.g., after a successful request)
-   */
-  reset?(): void;
-}
-
-/**
- * Provider configuration for infrastructure/connection settings
- */
-export interface ProviderConfig {
-  /**
-   * API key - string, async function, or key strategy
-   * @example 'sk-xxx'
-   * @example () => fetchKeyFromVault()
-   * @example new RoundRobinKeys(['sk-1', 'sk-2'])
-   */
-  apiKey?: string | (() => string | Promise<string>) | KeyStrategy;
-
-  /** Override the base API URL (for proxies, local models) */
-  baseUrl?: string;
-
-  /** Request timeout in milliseconds */
-  timeout?: number;
-
-  /** Custom fetch implementation (for logging, caching, custom TLS) */
-  fetch?: typeof fetch;
-
-  /** API version override */
-  apiVersion?: string;
-
-  /** Retry strategy for handling failures and rate limits */
-  retryStrategy?: RetryStrategy;
-}
-
-/**
- * A reference to a model, created by a provider factory
- *
- * @typeParam TOptions - Provider-specific options type
- */
-export interface ModelReference<TOptions = unknown> {
-  /** The model identifier */
-  readonly modelId: string;
-
-  /** The provider that created this reference */
-  readonly provider: Provider<TOptions>;
-}
-
-// Forward declarations for handler types (defined in llm.ts)
-// We use 'any' here since the full types are circular
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface LLMHandler<TParams = any> {
-  /** Bind model ID to create executable model */
-  bind(modelId: string): BoundLLMModel<TParams>;
-
-  /**
-   * Internal: Set the parent provider reference.
-   * Called by createProvider() after the provider is constructed.
-   * This allows bind() to return models with the correct provider reference.
-   * @internal
-   */
-  _setProvider?(provider: LLMProvider<TParams>): void;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface EmbeddingHandler<TParams = any> {
-  /** Supported input types */
-  readonly supportedInputs: ('text' | 'image')[];
-  /** Bind model ID to create executable model */
-  bind(modelId: string): BoundEmbeddingModel<TParams>;
-
-  /**
-   * Internal: Set the parent provider reference.
-   * @internal
-   */
-  _setProvider?(provider: EmbeddingProvider<TParams>): void;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface ImageHandler<TParams = any> {
-  /** Bind model ID to create executable model */
-  bind(modelId: string): BoundImageModel<TParams>;
-
-  /**
-   * Internal: Set the parent provider reference.
-   * @internal
-   */
-  _setProvider?(provider: ImageProvider<TParams>): void;
-}
-
-// Forward declarations for bound models
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface BoundLLMModel<TParams = any> {
-  readonly modelId: string;
-  readonly provider: LLMProvider<TParams>;
-  // Methods defined in llm.ts
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface BoundEmbeddingModel<TParams = any> {
-  readonly modelId: string;
-  readonly provider: EmbeddingProvider<TParams>;
-  readonly maxBatchSize: number;
-  readonly maxInputLength: number;
-  readonly dimensions: number;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface BoundImageModel<TParams = any> {
-  readonly modelId: string;
-  readonly provider: ImageProvider<TParams>;
-}
-
-/**
- * A provider factory function with metadata and modality handlers.
- *
- * @typeParam TOptions - Provider-specific options passed to the factory function
- */
-export interface Provider<TOptions = unknown> {
-  /** Create a model reference, optionally with provider-specific options */
-  (modelId: string, options?: TOptions): ModelReference<TOptions>;
-
-  /** Provider name */
-  readonly name: string;
-
-  /** Provider version */
-  readonly version: string;
-
-  /** Supported modalities */
-  readonly modalities: {
-    llm?: LLMHandler;
-    embedding?: EmbeddingHandler;
-    image?: ImageHandler;
-  };
-}
-
-/**
- * Provider with LLM modality
- *
- * @typeParam TParams - Model-specific parameters type
- * @typeParam TOptions - Provider-specific options type
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type LLMProvider<TParams = any, TOptions = unknown> = Provider<TOptions> & {
-  readonly modalities: { llm: LLMHandler<TParams> };
-};
-
-/**
- * Provider with Embedding modality
- *
- * @typeParam TParams - Model-specific parameters type
- * @typeParam TOptions - Provider-specific options type
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type EmbeddingProvider<TParams = any, TOptions = unknown> = Provider<TOptions> & {
-  readonly modalities: { embedding: EmbeddingHandler<TParams> };
-};
-
-/**
- * Provider with Image modality
- *
- * @typeParam TParams - Model-specific parameters type
- * @typeParam TOptions - Provider-specific options type
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type ImageProvider<TParams = any, TOptions = unknown> = Provider<TOptions> & {
-  readonly modalities: { image: ImageHandler<TParams> };
-};

package/src/types/schema.ts

@@ -1,58 +0,0 @@
-/**
- * JSON Schema types for tool parameters and structured outputs
- */
-
-export type JSONSchemaPropertyType =
-  | 'string'
-  | 'number'
-  | 'integer'
-  | 'boolean'
-  | 'array'
-  | 'object'
-  | 'null';
-
-/**
- * JSON Schema property definition
- */
-export interface JSONSchemaProperty {
-  type: JSONSchemaPropertyType;
-  description?: string;
-  enum?: unknown[];
-  const?: unknown;
-  default?: unknown;
-
-  // String-specific
-  minLength?: number;
-  maxLength?: number;
-  pattern?: string;
-  format?: 'email' | 'uri' | 'date' | 'date-time' | 'uuid';
-
-  // Number-specific
-  minimum?: number;
-  maximum?: number;
-  exclusiveMinimum?: number;
-  exclusiveMaximum?: number;
-  multipleOf?: number;
-
-  // Array-specific
-  items?: JSONSchemaProperty;
-  minItems?: number;
-  maxItems?: number;
-  uniqueItems?: boolean;
-
-  // Object-specific
-  properties?: Record<string, JSONSchemaProperty>;
-  required?: string[];
-  additionalProperties?: boolean;
-}
-
-/**
- * JSON Schema for tool parameters or structured outputs
- */
-export interface JSONSchema {
-  type: 'object';
-  properties: Record<string, JSONSchemaProperty>;
-  required?: string[];
-  additionalProperties?: boolean;
-  description?: string;
-}

package/src/types/stream.ts

@@ -1,188 +0,0 @@
-import type { Turn } from './turn.ts';
-
-/**
- * Stream event types
- */
-export type StreamEventType =
-  | 'text_delta'
-  | 'reasoning_delta'
-  | 'image_delta'
-  | 'audio_delta'
-  | 'video_delta'
-  | 'tool_call_delta'
-  | 'tool_execution_start'
-  | 'tool_execution_end'
-  | 'message_start'
-  | 'message_stop'
-  | 'content_block_start'
-  | 'content_block_stop';
-
-/**
- * Event delta data (type-specific)
- */
-export interface EventDelta {
-  text?: string;
-  data?: Uint8Array;
-  toolCallId?: string;
-  toolName?: string;
-  argumentsJson?: string;
-  /** Tool execution result (for tool_execution_end) */
-  result?: unknown;
-  /** Whether tool execution errored (for tool_execution_end) */
-  isError?: boolean;
-  /** Timestamp in ms (for tool_execution_start/end) */
-  timestamp?: number;
-}
-
-/**
- * A streaming event
- */
-export interface StreamEvent {
-  /** Event type */
-  type: StreamEventType;
-
-  /** Index of the content block this event belongs to */
-  index: number;
-
-  /** Event data (type-specific) */
-  delta: EventDelta;
-}
-
-/**
- * Stream result - async iterable that also provides final turn
- */
-export interface StreamResult<TData = unknown>
-  extends AsyncIterable<StreamEvent> {
-  /**
-   * Get the complete Turn after streaming finishes.
-   * Resolves when the stream completes.
-   */
-  readonly turn: Promise<Turn<TData>>;
-
-  /** Abort the stream */
-  abort(): void;
-}
-
-/**
- * Create a stream result from an async generator and completion promise
- */
-export function createStreamResult<TData = unknown>(
-  generator: AsyncGenerator<StreamEvent, void, unknown>,
-  turnPromise: Promise<Turn<TData>>,
-  abortController: AbortController
-): StreamResult<TData> {
-  return {
-    [Symbol.asyncIterator]() {
-      return generator;
-    },
-    turn: turnPromise,
-    abort() {
-      abortController.abort();
-    },
-  };
-}
-
-/**
- * Create a text delta event
- */
-export function textDelta(text: string, index = 0): StreamEvent {
-  return {
-    type: 'text_delta',
-    index,
-    delta: { text },
-  };
-}
-
-/**
- * Create a tool call delta event
- */
-export function toolCallDelta(
-  toolCallId: string,
-  toolName: string,
-  argumentsJson: string,
-  index = 0
-): StreamEvent {
-  return {
-    type: 'tool_call_delta',
-    index,
-    delta: { toolCallId, toolName, argumentsJson },
-  };
-}
-
-/**
- * Create a message start event
- */
-export function messageStart(): StreamEvent {
-  return {
-    type: 'message_start',
-    index: 0,
-    delta: {},
-  };
-}
-
-/**
- * Create a message stop event
- */
-export function messageStop(): StreamEvent {
-  return {
-    type: 'message_stop',
-    index: 0,
-    delta: {},
-  };
-}
-
-/**
- * Create a content block start event
- */
-export function contentBlockStart(index: number): StreamEvent {
-  return {
-    type: 'content_block_start',
-    index,
-    delta: {},
-  };
-}
-
-/**
- * Create a content block stop event
- */
-export function contentBlockStop(index: number): StreamEvent {
-  return {
-    type: 'content_block_stop',
-    index,
-    delta: {},
-  };
-}
-
-/**
- * Create a tool execution start event
- */
-export function toolExecutionStart(
-  toolCallId: string,
-  toolName: string,
-  timestamp: number,
-  index = 0
-): StreamEvent {
-  return {
-    type: 'tool_execution_start',
-    index,
-    delta: { toolCallId, toolName, timestamp },
-  };
-}
-
-/**
- * Create a tool execution end event
- */
-export function toolExecutionEnd(
-  toolCallId: string,
-  toolName: string,
-  result: unknown,
-  isError: boolean,
-  timestamp: number,
-  index = 0
-): StreamEvent {
-  return {
-    type: 'tool_execution_end',
-    index,
-    delta: { toolCallId, toolName, result, isError, timestamp },
-  };
-}