@stacksjs/ai 0.70.88 → 0.70.90

package/dist/text.js

@@ -0,0 +1,51 @@
+import { invokeModel } from "./utils/client-bedrock-runtime";
+const DEFAULT_MODEL = "amazon.titan-text-express-v1";
+function resolveModel(override) {
+  if (override)
+    return override;
+  return globalThis.config?.ai?.bedrock?.model || process.env.BEDROCK_MODEL_ID || DEFAULT_MODEL;
+}
+export async function summarize(text, options = {}) {
+  const { maxTokenCount = 512, temperature = 0, topP = 0.9, modelId } = options;
+  try {
+    const response = await invokeModel({
+      modelId: resolveModel(modelId),
+      contentType: "application/json",
+      accept: "*/*",
+      body: JSON.stringify({
+        inputText: `Summarize the following text: ${text}`,
+        textGenerationConfig: {
+          maxTokenCount,
+          stopSequences: [],
+          temperature,
+          topP
+        }
+      })
+    });
+    return JSON.parse(new TextDecoder().decode(response.body)).results[0].outputText;
+  } catch (error) {
+    throw Error(`Error summarizing text: ${error.message}`);
+  }
+}
+export async function ask(question, options = {}) {
+  const { maxTokenCount = 512, temperature = 0, topP = 0.9, modelId } = options;
+  try {
+    const response = await invokeModel({
+      modelId: resolveModel(modelId),
+      contentType: "application/json",
+      accept: "*/*",
+      body: JSON.stringify({
+        inputText: question,
+        textGenerationConfig: {
+          maxTokenCount,
+          stopSequences: [],
+          temperature,
+          topP
+        }
+      })
+    });
+    return JSON.parse(new TextDecoder().decode(response.body)).results[0].outputText;
+  } catch (error) {
+    throw Error(`Error asking question: ${error.message}`);
+  }
+}

package/dist/types.d.ts

@@ -0,0 +1,185 @@
+/**
+ * AI Module Types
+ *
+ * Shared type definitions for AI drivers and agents.
+ */
+export declare interface AIMessage {
+  role: 'user' | 'assistant' | 'system'
+  content: string | AIMessageContent[]
+}
+export declare interface AIMessageContent {
+  type: 'text' | 'image_url' | 'image'
+  text?: string
+  image_url?: { url: string, detail?: 'auto' | 'low' | 'high' }
+  source?: { type: 'base64', media_type: string, data: string }
+}
+export declare interface AIDriver {
+  name: string
+  process: (command: string, context: string, history: AIMessage[]) => Promise<string>
+  stream?: (command: string, context: string, history: AIMessage[]) => AsyncGenerator<string>
+  embed?: (input: string | string[]) => Promise<number[] | number[][]>
+}
+export declare interface AIDriverConfig {
+  apiKey?: string
+  baseUrl?: string
+  model?: string
+  maxTokens?: number
+}
+export declare interface StreamingResult {
+  stream: ReadableStream<Uint8Array>
+  fullResponse: Promise<string>
+}
+export declare interface EmbeddingResult {
+  embedding: number[]
+  index: number
+  object: string
+}
+export declare interface EmbeddingsResponse {
+  data: EmbeddingResult[]
+  model: string
+  usage: {
+    prompt_tokens: number
+    total_tokens: number
+  }
+}
+/**
+ * Tool / function definition that the model can call back into.
+ * Cross-provider shape: OpenAI's `tools[]` and Anthropic's `tools[]`
+ * map to this same structure via the JSON Schema for parameters.
+ */
+export declare interface AITool {
+  name: string
+  description?: string
+  parameters?: Record<string, unknown>
+}
+export declare interface ChatCompletionOptions {
+  model?: string
+  maxTokens?: number
+  temperature?: number
+  topP?: number
+  stop?: string | string[]
+  stream?: boolean
+  tools?: AITool[]
+  toolChoice?: 'auto' | 'required' | 'none' | { name: string }
+  responseFormat?: AIResponseFormat
+}
+export declare interface AIResult {
+  content: string
+  model: string
+  usage?: {
+    promptTokens: number
+    completionTokens: number
+    totalTokens: number
+  }
+  finishReason?: string
+}
+export declare interface ClaudeAPIResponse {
+  content: Array<{ type: string, text: string }>
+}
+export declare interface OpenAIAPIResponse {
+  choices: Array<{ message: { content: string } }>
+}
+export declare interface OllamaAPIResponse {
+  message: { content: string }
+}
+export declare interface ClaudeStreamEvent {
+  type: string
+  subtype?: string
+  message?: {
+    content: Array<{
+      type: string
+      text?: string
+      name?: string
+      input?: Record<string, unknown>
+    }>
+  }
+  delta?: { text?: string }
+  result?: string
+  index?: number
+  content_block?: {
+    type: string
+    text?: string
+  }
+}
+// Buddy Types
+export declare interface RepoState {
+  path: string
+  name: string
+  branch: string
+  hasChanges: boolean
+  lastCommit?: string
+}
+export declare interface GitHubCredentials {
+  token: string
+  username: string
+  name: string
+  email: string
+}
+export declare interface BuddyState {
+  repo: RepoState | null
+  conversationHistory: AIMessage[]
+  currentDriver: string
+  github: GitHubCredentials | null
+}
+export declare interface BuddyConfig {
+  workDir: string
+  commitMessage: string
+  ollamaHost: string
+  ollamaModel: string
+}
+export declare interface BuddyApiKeys {
+  anthropic?: string
+  openai?: string
+  claudeCliHost?: string
+}
+// Image types
+export declare interface ImageGenerationConfig {
+  provider: 'openai'
+  model?: string
+  apiKey?: string
+}
+// Search/RAG types
+export declare interface SearchConfig {
+  embeddingProvider: 'openai' | 'ollama'
+  embeddingModel?: string
+  generationProvider?: 'anthropic' | 'openai' | 'ollama'
+  generationModel?: string
+}
+// MCP types
+export declare interface MCPConfig {
+  servers: Array<{
+    name: string
+    command?: string
+    args?: string[]
+    url?: string
+    env?: Record<string, string>
+  }>
+}
+// AI module config (used by @stacksjs/config)
+export declare interface AIConfig {
+  default?: string
+  models?: string[]
+  drivers?: {
+    anthropic?: AIDriverConfig & { anthropicVersion?: string }
+    openai?: AIDriverConfig & { embeddingModel?: string }
+    ollama?: AIDriverConfig & { host?: string; embeddingModel?: string }
+  }
+  image?: ImageGenerationConfig
+  search?: SearchConfig
+  mcp?: MCPConfig
+}
+/**
+ * Structured-output / JSON-mode response format. Modeled after
+ * OpenAI's `response_format` but the Anthropic driver maps it to
+ * the tools-as-json pattern internally (stacksjs/stacks#1878 A-1).
+ */
+export type AIResponseFormat = | { type: 'text' }
+  | { type: 'json_object' }
+  | {
+      type: 'json_schema'
+      json_schema: {
+        name: string
+        schema: Record<string, unknown>
+        strict?: boolean
+      }
+    }

package/dist/utils/client-bedrock-runtime.d.ts

@@ -0,0 +1,16 @@
+import type { InvokeModelCommandInput, InvokeModelCommandOutput, InvokeModelWithResponseStreamCommandInput, InvokeModelWithResponseStreamCommandOutput } from '@stacksjs/ts-cloud/aws';
+export type { InvokeModelCommandInput, InvokeModelWithResponseStreamCommandInput };
+/*
+ * Invoke Model
+ * @param {InvokeModelCommandInput} params
+ * @returns {Promise<InvokeModelCommandOutput>}
+ * @see https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/BedrockRuntime.html#invokeModel-property
+ */
+export declare function invokeModel(params: InvokeModelCommandInput): Promise<InvokeModelCommandOutput>;
+/*
+ * Invoke Model With Response Stream
+ * @param {InvokeModelWithResponseStreamCommandInput} params
+ * @returns {Promise<InvokeModelWithResponseStreamCommandOutput>}
+ * @see https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/BedrockRuntime.html#invokeModelWithResponseStream-property
+ */
+export declare function invokeModelWithResponseStream(params: InvokeModelWithResponseStreamCommandInput): Promise<InvokeModelWithResponseStreamCommandOutput>;

package/dist/utils/client-bedrock-runtime.js

@@ -0,0 +1,17 @@
+import process from "node:process";
+let _client = null;
+async function getClient() {
+  if (_client)
+    return _client;
+  const mod = await import("@stacksjs/ts-cloud/aws");
+  if (!mod?.BedrockRuntimeClient)
+    throw Error("@stacksjs/ts-cloud/aws does not export BedrockRuntimeClient \u2014 rebuild ts-cloud or remove the AI dependency.");
+  _client = new mod.BedrockRuntimeClient(process.env.REGION || "us-east-1");
+  return _client;
+}
+export async function invokeModel(params) {
+  return (await getClient()).invokeModel(params);
+}
+export async function invokeModelWithResponseStream(params) {
+  return (await getClient()).invokeModelWithResponseStream(params);
+}

package/dist/utils/client-bedrock.d.ts

@@ -0,0 +1,27 @@
+import type { CreateModelCustomizationJobCommandInput, CreateModelCustomizationJobCommandOutput, GetModelCustomizationJobCommandInput, GetModelCustomizationJobCommandOutput, ListFoundationModelsCommandInput, ListFoundationModelsCommandOutput } from '@stacksjs/ts-cloud/aws';
+export type {
+  CreateModelCustomizationJobCommandInput,
+  GetModelCustomizationJobCommandInput,
+  ListFoundationModelsCommandInput,
+};
+/*
+ * Create Model Customization Job
+ * @param {CreateModelCustomizationJobCommandInput} params
+ * @returns {Promise<CreateModelCustomizationJobCommandOutput>}
+ * @see https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Bedrock.html#CreateModelCustomizationJob-property
+ */
+export declare function createModelCustomizationJob(param: CreateModelCustomizationJobCommandInput): Promise<CreateModelCustomizationJobCommandOutput>;
+/*
+ * Get Model Customization Job
+ * @param {GetModelCustomizationJobCommandInput} params
+ * @returns {Promise<GetModelCustomizationJobCommandOutput>}
+ * @see https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Bedrock.html#getModelCustomizationJob-property
+ */
+export declare function getModelCustomizationJob(params: GetModelCustomizationJobCommandInput): Promise<GetModelCustomizationJobCommandOutput>;
+/*
+ * List Foundation Models
+ * @param {ListFoundationModelsCommandInput} params
+ * @returns {Promise<ListFoundationModelsCommandOutput>}
+ * @see https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Bedrock.html#listFoundationModels-property
+ */
+export declare function listFoundationModels(params: ListFoundationModelsCommandInput): Promise<ListFoundationModelsCommandOutput>;

package/dist/utils/client-bedrock.js

@@ -0,0 +1,20 @@
+import process from "node:process";
+let _client = null;
+async function getClient() {
+  if (_client)
+    return _client;
+  const mod = await import("@stacksjs/ts-cloud/aws");
+  if (!mod?.BedrockClient)
+    throw Error("@stacksjs/ts-cloud/aws does not export BedrockClient \u2014 rebuild ts-cloud or remove the AI dependency.");
+  _client = new mod.BedrockClient(process.env.REGION || "us-east-1");
+  return _client;
+}
+export async function createModelCustomizationJob(param) {
+  return (await getClient()).createModelCustomizationJob(param);
+}
+export async function getModelCustomizationJob(params) {
+  return (await getClient()).getModelCustomizationJob(params);
+}
+export async function listFoundationModels(params) {
+  return (await getClient()).listFoundationModels(params);
+}

package/dist/utils/model-access.d.ts

@@ -0,0 +1 @@
+export declare function requestModelAccess(): Promise<void>;

package/dist/utils/model-access.js

@@ -0,0 +1,21 @@
+import { log } from "@stacksjs/cli";
+import { ai } from "@stacksjs/config";
+async function getBedrockClient() {
+  const mod = await import("@stacksjs/ts-cloud/aws");
+  if (!mod?.BedrockClient)
+    throw Error("@stacksjs/ts-cloud/aws does not export BedrockClient \u2014 rebuild ts-cloud or remove the AI dependency.");
+  return new mod.BedrockClient("us-east-1");
+}
+export async function requestModelAccess() {
+  const client = await getBedrockClient(), models = ai.models;
+  if (!models)
+    throw Error("No AI models found. Please set ./config/ai.ts values.");
+  for (const model of models)
+    try {
+      log.info(`Requesting access to model ${model}`);
+      const data = await client.requestModelAccess({ modelId: model });
+      log.info(`Response for model ${model}:`, data);
+    } catch (error) {
+      log.error(`Error requesting access to model ${model}:`, error);
+    }
+}

package/dist/utils/retry.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Fetch with automatic retry on 429 / 5xx. Returns the final
+ * `Response` — the caller checks `.ok` and parses the body as usual.
+ *
+ * Does NOT retry network-level errors (connection reset, DNS
+ * failure) — those throw synchronously and the caller's existing
+ * try/catch handles them.
+ */
+export declare function fetchWithRetry(input: RequestInfo | URL, init?: RequestInit, config?: RetryConfig): Promise<Response>;
+/**
+ * Retry helper for AI driver HTTP calls (stacksjs/stacks#1878 A-5).
+ *
+ * Background: OpenAI / Anthropic / etc. routinely return 429 (rate
+ * limit) and 5xx (capacity / overloaded) responses with a
+ * `Retry-After` header indicating when the caller should try again.
+ * The pre-fix AI drivers threw immediately on any non-2xx, surfacing
+ * transient capacity issues as hard user-facing failures.
+ *
+ * This helper wraps `fetch()` with:
+ *   - Honor `Retry-After` (seconds or HTTP-date) for 429 + 503
+ *   - Exponential backoff + jitter for other 5xx
+ *   - Cap at `maxRetries` attempts (default 3)
+ *   - Surface the final non-recoverable response to the caller
+ *
+ * No retry on 4xx other than 429 — those are caller bugs (bad API
+ * key, malformed request) that won't clear with more retries.
+ */
+/**
+ * Configurable retry policy. Defaults are tuned for the typical
+ * "Anthropic returned 429, try again in 3s" case without being so
+ * aggressive that a permanent outage hangs the request loop for
+ * minutes.
+ */
+export declare interface RetryConfig {
+  maxRetries?: number
+  baseDelayMs?: number
+  maxDelayMs?: number
+}

package/dist/utils/retry.js

@@ -0,0 +1,39 @@
+const DEFAULT_RETRY = {
+  maxRetries: 3,
+  baseDelayMs: 500,
+  maxDelayMs: 30000
+};
+export async function fetchWithRetry(input, init, config = {}) {
+  const cfg = { ...DEFAULT_RETRY, ...config };
+  let lastResponse;
+  for (let attempt = 0;attempt <= cfg.maxRetries; attempt++) {
+    lastResponse = await fetch(input, init);
+    if (lastResponse.ok)
+      return lastResponse;
+    if (lastResponse.status < 500 && lastResponse.status !== 429)
+      return lastResponse;
+    if (attempt === cfg.maxRetries)
+      return lastResponse;
+    const backoff = parseRetryAfter(lastResponse.headers.get("Retry-After")) ?? exponentialBackoff(attempt, cfg), delay = Math.min(backoff, cfg.maxDelayMs);
+    try {
+      await lastResponse.text().catch(() => {});
+    } catch {}
+    await new Promise((resolve) => setTimeout(resolve, delay));
+  }
+  return lastResponse;
+}
+function parseRetryAfter(header) {
+  if (!header)
+    return null;
+  const seconds = Number.parseInt(header, 10);
+  if (Number.isFinite(seconds) && String(seconds) === header.trim())
+    return Math.max(0, seconds * 1000);
+  const dateMs = Date.parse(header);
+  if (Number.isFinite(dateMs))
+    return Math.max(0, dateMs - Date.now());
+  return null;
+}
+function exponentialBackoff(attempt, cfg) {
+  const cap = Math.min(cfg.baseDelayMs * 2 ** attempt, cfg.maxDelayMs);
+  return Math.random() * cap;
+}

package/dist/utils/tokens.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Estimate the number of tokens in `text` for the given model.
+ * Heuristic only — for exact counts, use the provider's tokenizer.
+ *
+ * @example
+ * ```ts
+ * if (estimateTokens(prompt, 'gpt-4o') > 100_000) {
+ *   throw new Error('prompt too long; consider chunking')
+ * }
+ * ```
+ */
+export declare function estimateTokens(text: string, model?: string): number;
+/**
+ * Estimate total tokens for a chat-completion request: sum of
+ * every message's content plus a fixed per-message overhead
+ * (matches the rough "+4 per message + 2 for the conversation"
+ * heuristic OpenAI's docs publish).
+ */
+export declare function estimateMessageTokens(messages: Array<{ role: string, content: string | unknown }>, model?: string): number;
+/**
+ * Inspect `text` for common prompt-injection patterns. Returns
+ * `{ ok, matched, cleaned }`. Apps decide what to do with the
+ * result — reject the request (`if (!result.ok) throw...`), pass
+ * the cleaned text on (`useText(result.cleaned)`), or just log
+ * for audit while letting the original through.
+ *
+ * **Limits:** this is heuristic. Adversarial inputs can paraphrase
+ * around any specific pattern. Use as a cheap first filter; for
+ * real defense, isolate the user input from the system prompt
+ * structurally (different roles, JSON-mode for the system layer)
+ * and guard the output side too.
+ *
+ * @example
+ * ```ts
+ * const check = sanitizePrompt(userInput)
+ * if (!check.ok) {
+ *   log.warn('possible injection attempt', { patterns: check.matched })
+ *   // option A: reject
+ *   throw new HttpError(400, 'invalid input')
+ *   // option B: pass cleaned
+ *   await chat([{ role: 'user', content: check.cleaned }])
+ * }
+ * ```
+ */
+export declare function sanitizePrompt(text: string): SanitizeResult;
+export declare interface SanitizeResult {
+  ok: boolean
+  matched: string[]
+  cleaned: string
+}

package/dist/utils/tokens.js

@@ -0,0 +1,59 @@
+function charsPerToken(model) {
+  const m = model.toLowerCase();
+  if (m.startsWith("gpt-"))
+    return 3.5;
+  if (m.startsWith("claude"))
+    return 3.5;
+  return 3.5;
+}
+export function estimateTokens(text, model = "gpt-4o") {
+  if (!text)
+    return 0;
+  const ratio = charsPerToken(model);
+  return Math.max(1, Math.ceil(text.length / ratio));
+}
+export function estimateMessageTokens(messages, model = "gpt-4o") {
+  const PER_MESSAGE_OVERHEAD = 4;
+  let total = 2;
+  for (const msg of messages) {
+    total += PER_MESSAGE_OVERHEAD;
+    if (typeof msg.content === "string")
+      total += estimateTokens(msg.content, model);
+    else if (Array.isArray(msg.content)) {
+      for (const block of msg.content)
+        if (block.type === "text" && block.text)
+          total += estimateTokens(block.text, model);
+        else if (block.type === "image" || block.type === "image_url")
+          total += 100;
+    }
+  }
+  return total;
+}
+const INJECTION_PATTERNS = [
+  /\bignore\s+(?:all\s+)?(?:previous|prior|above)\s+instructions?\b/i,
+  /\bdisregard\s+(?:all\s+)?(?:previous|prior|above)\b/i,
+  /\bforget\s+(?:everything|all)\s+(?:you|i)\b/i,
+  /\byou\s+are\s+now\s+a\s+\w+/i,
+  /\bnew\s+instructions?:\s*/i,
+  /\bsystem\s*[:>]\s*/i,
+  /\b(?:reveal|show|print|output|display)\s+(?:your|the)\s+(?:system\s+)?prompt\b/i,
+  /<\s*\/?\s*system\s*>/i,
+  /\[INST\]|\[\/INST\]/i,
+  /^\s*###\s+(?:instruction|system)/im
+];
+export function sanitizePrompt(text) {
+  if (!text)
+    return { ok: !0, matched: [], cleaned: text };
+  const matched = [];
+  let cleaned = text;
+  for (const pattern of INJECTION_PATTERNS)
+    if (pattern.test(cleaned)) {
+      matched.push(pattern.toString());
+      cleaned = cleaned.replace(pattern, "[redacted]");
+    }
+  return {
+    ok: matched.length === 0,
+    matched,
+    cleaned
+  };
+}

package/dist/utils/usage.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Register a usage reporter. Returns an `unregister` callback for
+ * apps that want to swap reporters at runtime (test setup/teardown,
+ * tenant isolation, etc.).
+ */
+export declare function onUsage(reporter: UsageReporter): () => void;
+/**
+ * Drop every registered reporter. Useful for tests.
+ */
+export declare function clearUsageReporters(): void;
+/**
+ * Emit a usage record to every registered reporter. Called by
+ * driver completion paths after the response lands. Reporter
+ * errors are caught + logged so a misbehaving sink doesn't
+ * propagate up to the caller.
+ */
+export declare function recordUsage(record: UsageRecord): void;
+/**
+ * Snapshot the currently-registered reporters. Useful for tests
+ * to assert behavior without exposing the internal array.
+ */
+export declare function listUsageReporters(): readonly UsageReporter[];
+/**
+ * AI usage tracking (stacksjs/stacks#1878 A-6).
+ *
+ * Background: `AIResult.usage` returns token counts per-call but
+ * nothing aggregates them. Apps that want "this user has spent
+ * $X this month" build the aggregation themselves — wiring a
+ * listener on every model invocation, persisting the running
+ * total, etc.
+ *
+ * This module ships a singleton recorder that drivers emit to on
+ * each completion. Apps install one or more `UsageReporter`
+ * functions that get called with `{ provider, model, prompt_tokens,
+ * completion_tokens, timestamp, durationMs }` and decide what to
+ * do (store to DB, push to Datadog, etc.). Default behavior with
+ * no reporter is a no-op — the framework doesn't impose a sink.
+ */
+export declare interface UsageRecord {
+  provider: string
+  model: string
+  promptTokens: number
+  completionTokens: number
+  totalTokens: number
+  durationMs: number
+  timestamp: number
+  metadata?: Record<string, unknown>
+}
+/**
+ * A reporter is called once per recorded completion. Multiple
+ * reporters can be installed simultaneously; they fire in
+ * registration order. Reporters MUST NOT throw — errors are
+ * caught and logged but otherwise ignored so a flaky metrics
+ * sink doesn't break the user's completion call.
+ */
+export type UsageReporter = (record: UsageRecord) => void | Promise<void>;

package/dist/utils/usage.js

@@ -0,0 +1,27 @@
+const reporters = [];
+export function onUsage(reporter) {
+  reporters.push(reporter);
+  return () => {
+    const idx = reporters.indexOf(reporter);
+    if (idx >= 0)
+      reporters.splice(idx, 1);
+  };
+}
+export function clearUsageReporters() {
+  reporters.length = 0;
+}
+export function recordUsage(record) {
+  for (const reporter of reporters)
+    try {
+      const result = reporter(record);
+      if (result && typeof result.then === "function")
+        result.catch((err) => {
+          console.error("[ai/usage] reporter rejected:", err);
+        });
+    } catch (err) {
+      console.error("[ai/usage] reporter threw:", err);
+    }
+}
+export function listUsageReporters() {
+  return reporters;
+}

package/dist/utils/vision.d.ts

@@ -0,0 +1,22 @@
+import type { AIMessage, AIMessageContent } from '../types';
+/**
+ * Normalize an entire `messages` array for the requested provider.
+ * Messages whose `content` is a plain string pass through unchanged.
+ * Messages with a content array get each block translated.
+ */
+export declare function normalizeMessagesForProvider(messages: AIMessage[], provider: 'openai' | 'anthropic'): AIMessage[];
+/**
+ * Convenience: convert a single command + optional image inputs into
+ * an `AIMessage` content array suitable for `chat()` calls. Used by
+ * the higher-level `text()` / `chat()` helpers when a user passes
+ * `{ command, images }` together.
+ *
+ * @example
+ * ```ts
+ * const content = buildMessageWithImages('What is in this image?', [
+ *   { url: 'https://example.com/cat.jpg' },
+ * ])
+ * await chat([{ role: 'user', content }])
+ * ```
+ */
+export declare function buildMessageWithImages(command: string, images: Array<{ url?: string, dataBase64?: string, mediaType?: string, detail?: 'auto' | 'low' | 'high' }>): AIMessageContent[];