@xpert-ai/plugin-sdk 3.6.7 → 3.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xpert-ai/plugin-sdk",
-  "version": "3.6.7",
+  "version": "3.7.1",
   "license": "AGPL-3.0",
   "repository": {
     "type": "git",
@@ -22,6 +22,7 @@
     "@metad/contracts": "*",
     "@nestjs/common": "*",
     "@nestjs/core": "*",
+    "@nestjs/cqrs": "*",
     "lodash-es": "*",
     "i18next-fs-backend": "*",
     "i18next": "*",

package/src/index.d.ts

@@ -11,3 +11,5 @@ export * from './lib/toolset/index';
 export * from './lib/core/index';
 export * from './lib/data/index';
 export * from './lib/ai-model/index';
+export * from './lib/agent/index';
+export * from './lib/strategy';

package/src/lib/agent/index.d.ts

@@ -0,0 +1 @@
+export * from './middleware';

package/src/lib/agent/middleware/index.d.ts

@@ -0,0 +1,5 @@
+export * from './strategy.decorator';
+export * from './strategy.interface';
+export * from './strategy.registry';
+export * from './types';
+export * from './runtime';

package/src/lib/agent/middleware/runtime.d.ts

@@ -0,0 +1,57 @@
+import type { Runtime as LangGraphRuntime } from "@langchain/langgraph";
+import type { BaseMessage } from "@langchain/core/messages";
+/**
+ * Type for the agent's built-in state properties.
+ */
+export type AgentBuiltInState = {
+    /**
+     * Array of messages representing the conversation history.
+     *
+     * This includes all messages exchanged during the agent's execution:
+     * - Human messages: Input from the user
+     * - AI messages: Responses from the language model
+     * - Tool messages: Results from tool executions
+     * - System messages: System-level instructions or information
+     *
+     * Messages are accumulated throughout the agent's lifecycle and can be
+     * accessed or modified by middleware hooks during execution.
+     */
+    messages: BaseMessage[];
+    /**
+     * Structured response data returned by the agent when a `responseFormat` is configured.
+     *
+     * This property is only populated when you provide a `responseFormat` schema
+     * (as Zod or JSON schema) to the agent configuration. The agent will format
+     * its final output to match the specified schema and store it in this property.
+     *
+     * Note: The type is specified as `Record<string, unknown>` because TypeScript cannot
+     * infer the actual response format type in contexts like middleware, where the agent's
+     * generic type parameters are not accessible. You may need to cast this to your specific
+     * response type when accessing it.
+     */
+    structuredResponse?: Record<string, unknown>;
+};
+/**
+ * Type helper to check if TContext is an optional Zod schema
+ */
+type IsOptionalZodObject<T> = T extends any ? true : false;
+type IsDefaultZodObject<T> = T extends any ? true : false;
+export type WithMaybeContext<TContext> = undefined extends TContext ? {
+    readonly context?: TContext;
+} : IsOptionalZodObject<TContext> extends true ? {
+    readonly context?: TContext;
+} : IsDefaultZodObject<TContext> extends true ? {
+    readonly context?: TContext;
+} : {
+    readonly context: TContext;
+};
+/**
+ * Runtime information available to middleware (readonly).
+ */
+export type Runtime<TContext = unknown> = Partial<Omit<LangGraphRuntime<TContext>, "context" | "configurable">> & WithMaybeContext<TContext> & {
+    configurable?: {
+        thread_id?: string;
+        [key: string]: unknown;
+    };
+};
+export {};

package/src/lib/agent/middleware/strategy.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare const AGENT_MIDDLEWARE_STRATEGY = "AGENT_MIDDLEWARE_STRATEGY";
+export declare const AgentMiddlewareStrategy: (provider: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/src/lib/agent/middleware/strategy.interface.d.ts

@@ -0,0 +1,16 @@
+import { IWFNMiddleware, TAgentMiddlewareMeta } from '@metad/contracts';
+import { AgentMiddleware, PromiseOrValue } from './types';
+export interface IAgentMiddlewareContext {
+    tenantId: string;
+    userId: string;
+    workspaceId?: string;
+    projectId?: string;
+    conversationId?: string;
+    xpertId?: string;
+    agentKey?: string;
+    node: IWFNMiddleware;
+}
+export interface IAgentMiddlewareStrategy<T = unknown> {
+    meta: TAgentMiddlewareMeta;
+    createMiddleware(options: T, context: IAgentMiddlewareContext): PromiseOrValue<AgentMiddleware>;
+}

package/src/lib/agent/middleware/strategy.registry.d.ts

@@ -0,0 +1,6 @@
+import { DiscoveryService, Reflector } from '@nestjs/core';
+import { BaseStrategyRegistry } from '../../strategy';
+import { IAgentMiddlewareStrategy } from './strategy.interface';
+export declare class AgentMiddlewareRegistry extends BaseStrategyRegistry<IAgentMiddlewareStrategy> {
+    constructor(discoveryService: DiscoveryService, reflector: Reflector);
+}

package/src/lib/agent/middleware/types.d.ts

@@ -0,0 +1,251 @@
+import { LanguageModelLike } from '@langchain/core/language_models/base';
+import { AIMessage, BaseMessage, SystemMessage } from '@langchain/core/messages';
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { InteropZodObject } from '@langchain/core/utils/types';
+import { Runtime } from './runtime';
+/**
+ * jump targets (user facing)
+ */
+export declare const JUMP_TO_TARGETS: readonly ["model", "tools", "end"];
+export type JumpToTarget = (typeof JUMP_TO_TARGETS)[number];
+export type PromiseOrValue<T> = T | Promise<T>;
+/**
+ * Result type for middleware functions.
+ */
+export type MiddlewareResult<TState> = (TState & {
+    jumpTo?: JumpToTarget;
+}) | void;
+/**
+ * Handler function type for the beforeAgent hook.
+ * Called once at the start of agent invocation before any model calls or tool executions.
+ *
+ * @param state - The current agent state (includes both middleware state and built-in state)
+ * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.
+ * @returns A middleware result containing partial state updates or undefined to pass through
+ */
+type BeforeAgentHandler<TSchema, TContext> = (state: TSchema, runtime: TContext) => PromiseOrValue<MiddlewareResult<Partial<TSchema>>>;
+/**
+ * Hook type for the beforeAgent lifecycle event.
+ * Can be either a handler function or an object with a handler and optional jump targets.
+ * This hook is called once at the start of the agent invocation.
+ */
+export type BeforeAgentHook<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = BeforeAgentHandler<TSchema, TContext> | {
+    hook: BeforeAgentHandler<TSchema, TContext>;
+    canJumpTo?: JumpToTarget[];
+};
+/**
+ * Handler function type for the beforeModel hook.
+ * Called before the model is invoked and before the wrapModelCall hook.
+ *
+ * @param state - The current agent state (includes both middleware state and built-in state)
+ * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.
+ * @returns A middleware result containing partial state updates or undefined to pass through
+ */
+export type BeforeModelHandler<TSchema, TContext> = (state: TSchema, runtime: TContext) => PromiseOrValue<MiddlewareResult<Partial<TSchema>>>;
+/**
+ * Hook type for the beforeModel lifecycle event.
+ * Can be either a handler function or an object with a handler and optional jump targets.
+ * This hook is called before each model invocation.
+ */
+export type BeforeModelHook<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = BeforeModelHandler<TSchema, TContext> | {
+    hook: BeforeModelHandler<TSchema, TContext>;
+    canJumpTo?: JumpToTarget[];
+};
+/**
+ * Handler function type for the afterModel hook.
+ * Called after the model is invoked and before any tools are called.
+ * Allows modifying the agent state after model invocation, e.g., to update tool call parameters.
+ *
+ * @param state - The current agent state (includes both middleware state and built-in state)
+ * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.
+ * @returns A middleware result containing partial state updates or undefined to pass through
+ */
+export type AfterModelHandler<TSchema, TContext> = (state: TSchema, runtime: TContext) => PromiseOrValue<MiddlewareResult<Partial<TSchema>>>;
+/**
+ * Hook type for the afterModel lifecycle event.
+ * Can be either a handler function or an object with a handler and optional jump targets.
+ * This hook is called after each model invocation.
+ */
+export type AfterModelHook<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = AfterModelHandler<TSchema, TContext> | {
+    hook: AfterModelHandler<TSchema, TContext>;
+    canJumpTo?: JumpToTarget[];
+};
+/**
+ * Handler function type for the afterAgent hook.
+ * Called once at the end of agent invocation after all model calls and tool executions are complete.
+ *
+ * @param state - The current agent state (includes both middleware state and built-in state)
+ * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.
+ * @returns A middleware result containing partial state updates or undefined to pass through
+ */
+type AfterAgentHandler<TSchema, TContext> = (state: TSchema, runtime: TContext) => PromiseOrValue<MiddlewareResult<Partial<TSchema>>>;
+/**
+ * Hook type for the afterAgent lifecycle event.
+ * Can be either a handler function or an object with a handler and optional jump targets.
+ * This hook is called once at the end of the agent invocation.
+ */
+export type AfterAgentHook<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = AfterAgentHandler<TSchema, TContext> | {
+    hook: AfterAgentHandler<TSchema, TContext>;
+    canJumpTo?: JumpToTarget[];
+};
+/**
+ * Configuration for modifying a model call at runtime.
+ * All fields are optional and only provided fields will override defaults.
+ *
+ * @template TState - The agent's state type, must extend Record<string, unknown>. Defaults to Record<string, unknown>.
+ * @template TContext - The runtime context type for accessing metadata and control flow. Defaults to unknown.
+ */
+export interface ModelRequest<TState = any, TContext = unknown> {
+    /**
+     * The model to use for this step.
+     */
+    model: LanguageModelLike;
+    /**
+     * The messages to send to the model.
+     */
+    messages: BaseMessage[];
+    systemMessage?: SystemMessage;
+    runtime: Runtime<TContext>;
+}
+/**
+ * Handler function type for wrapping model calls.
+ * Takes a model request and returns the AI message response.
+ *
+ * @param request - The model request containing model, messages, systemPrompt, tools, state, and runtime
+ * @returns The AI message response from the model
+ */
+export type WrapModelCallHandler<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = (request: ModelRequest<TSchema, TContext>) => PromiseOrValue<AIMessage>;
+/**
+ * Wrapper function type for the wrapModelCall hook.
+ * Allows middleware to intercept and modify model execution.
+ * This enables you to:
+ * - Modify the request before calling the model (e.g., change system prompt, add/remove tools)
+ * - Handle errors and retry with different parameters
+ * - Post-process the response
+ * - Implement custom caching, logging, or other cross-cutting concerns
+ *
+ * @param request - The model request containing all parameters needed for the model call
+ * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response
+ * @returns The AI message response from the model (or a modified version)
+ */
+export type WrapModelCallHook<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = (request: ModelRequest<TSchema, TContext>, handler: WrapModelCallHandler<TSchema, TContext>) => PromiseOrValue<AIMessage>;
+export interface AgentMiddleware<TSchema extends InteropZodObject | undefined = any, TContextSchema extends InteropZodObject | undefined = any, TFullContext = any> {
+    /**
+     * The name of the middleware.
+     */
+    name: string;
+    /**
+     * The schema of the middleware state. Middleware state is persisted between multiple invocations. It can be either:
+     * - A Zod object
+     * - A Zod optional object
+     * - A Zod default object
+     * - Undefined
+     */
+    stateSchema?: TSchema;
+    /**
+     * The schema of the middleware context. Middleware context is read-only and not persisted between multiple invocations. It can be either:
+     * - A Zod object
+     * - A Zod optional object
+     * - A Zod default object
+     * - Undefined
+     */
+    contextSchema?: TContextSchema;
+    tools?: DynamicStructuredTool[];
+    beforeAgent?: BeforeAgentHook<TSchema, TFullContext>;
+    beforeModel?: BeforeModelHook<TSchema, TFullContext>;
+    afterModel?: AfterModelHook<TSchema, TFullContext>;
+    afterAgent?: AfterAgentHook<TSchema, TFullContext>;
+    /**
+     * Wraps the model invocation with custom logic. This allows you to:
+     * - Modify the request before calling the model
+     * - Handle errors and retry with different parameters
+     * - Post-process the response
+     * - Implement custom caching, logging, or other cross-cutting concerns
+     *
+     * @param request - The model request containing model, messages, systemPrompt, tools, state, and runtime.
+     * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response.
+     * @returns The response from the model (or a modified version).
+     *
+     * @example
+     * ```ts
+     * wrapModelCall: async (request, handler) => {
+     *   // Modify request before calling
+     *   const modifiedRequest = { ...request, systemPrompt: "You are helpful" };
+     *
+     *   try {
+     *     // Call the model
+     *     return await handler(modifiedRequest);
+     *   } catch (error) {
+     *     // Handle errors and retry with fallback
+     *     const fallbackRequest = { ...request, model: fallbackModel };
+     *     return await handler(fallbackRequest);
+     *   }
+     * }
+     * ```
+     */
+    wrapModelCall?: WrapModelCallHook<TSchema, TFullContext>;
+    /**
+     * Wraps tool execution with custom logic. This allows you to:
+     * - Modify tool call parameters before execution
+     * - Handle errors and retry with different parameters
+     * - Post-process tool results
+     * - Implement caching, logging, authentication, or other cross-cutting concerns
+     * - Return Command objects for advanced control flow
+     *
+     * The handler receives a ToolCallRequest containing the tool call, state, and runtime,
+     * along with a handler function to execute the actual tool.
+     *
+     * @param request - The tool call request containing toolCall, state, and runtime.
+     * @param handler - The function that executes the tool. Call this with a ToolCallRequest to get the result.
+     * @returns The tool result as a ToolMessage or a Command for advanced control flow.
+     *
+     * @example
+     * ```ts
+     * wrapToolCall: async (request, handler) => {
+     *   console.log(`Calling tool: ${request.tool.name}`);
+     *   console.log(`Tool description: ${request.tool.description}`);
+     *
+     *   try {
+     *     // Execute the tool
+     *     const result = await handler(request);
+     *     console.log(`Tool ${request.tool.name} succeeded`);
+     *     return result;
+     *   } catch (error) {
+     *     console.error(`Tool ${request.tool.name} failed:`, error);
+     *     // Could return a custom error message or retry
+     *     throw error;
+     *   }
+     * }
+     * ```
+     *
+     * @example Authentication
+     * ```ts
+     * wrapToolCall: async (request, handler) => {
+     *   // Check if user is authorized for this tool
+     *   if (!request.runtime.context.isAuthorized(request.tool.name)) {
+     *     return new ToolMessage({
+     *       content: "Unauthorized to call this tool",
+     *       tool_call_id: request.toolCall.id,
+     *     });
+     *   }
+     *   return handler(request);
+     * }
+     * ```
+     *
+     * @example Caching
+     * ```ts
+     * const cache = new Map();
+     * wrapToolCall: async (request, handler) => {
+     *   const cacheKey = `${request.tool.name}:${JSON.stringify(request.toolCall.args)}`;
+     *   if (cache.has(cacheKey)) {
+     *     return cache.get(cacheKey);
+     *   }
+     *   const result = await handler(request);
+     *   cache.set(cacheKey, result);
+     *   return result;
+     * }
+     * ```
+     */
+    wrapToolCall?: (request: ModelRequest<TSchema, TFullContext>, handler: WrapModelCallHandler<TSchema, TFullContext>) => PromiseOrValue<AIMessage>;
+}
+export {};

package/src/lib/agent/skill/index.d.ts

@@ -0,0 +1,3 @@
+export * from './skill-source-provider.interface';
+export * from './skill-source-provider.registry';
+export * from './skill-source-provider.decorator';

package/src/lib/agent/skill/skill-source-provider.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare const SKILL_SOURCE_PROVIDER = "SKILL_SOURCE_PROVIDER";
+export declare const SkillSourceProviderStrategy: (provider: string) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/src/lib/agent/skill/skill-source-provider.interface.d.ts

@@ -0,0 +1,23 @@
+import { ISkillRepository, ISkillRepositoryIndex, TSkillSourceMeta } from "@metad/contracts";
+export interface ISkillSourceProvider {
+    type: string;
+    meta: TSkillSourceMeta;
+    /**
+     * Whether the provider can handle a given source type
+     */
+    canHandle(sourceType: string): boolean;
+    /**
+     * List skill index entries from a source
+     */
+    listSkills(config: ISkillRepository): Promise<ISkillRepositoryIndex[]>;
+    /**
+     * Fetch a concrete skill package into a temporary directory
+     */
+    installSkillPackage(index: ISkillRepositoryIndex, installDir: string): Promise<string>;
+    /**
+     * Uninstall a skill package from a given path.
+     *
+     * @param path
+     */
+    uninstallSkillPackage(path: string): Promise<void>;
+}

package/src/lib/agent/skill/skill-source-provider.registry.d.ts

@@ -0,0 +1,6 @@
+import { DiscoveryService, Reflector } from '@nestjs/core';
+import { BaseStrategyRegistry } from '../../strategy';
+import { ISkillSourceProvider } from './skill-source-provider.interface';
+export declare class SkillSourceProviderRegistry extends BaseStrategyRegistry<ISkillSourceProvider> {
+    constructor(discoveryService: DiscoveryService, reflector: Reflector);
+}

package/src/lib/ai-model/commands/create-model-client.command.d.ts

@@ -0,0 +1,21 @@
+import { Embeddings } from '@langchain/core/embeddings';
+import { BaseLanguageModel } from '@langchain/core/language_models/base';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { ICopilotModel, ILLMUsage } from '@metad/contracts';
+import { Command } from '@nestjs/cqrs';
+import { IRerank } from '../types';
+/**
+ * Get a Chat Model of copilot model and check it's token limitation, record the token usage
+ */
+export declare class CreateModelClientCommand<T = BaseLanguageModel | BaseChatModel | Embeddings | IRerank> extends Command<T> {
+    readonly copilotModel: ICopilotModel;
+    readonly options: {
+        abortController?: AbortController;
+        usageCallback: (tokens: ILLMUsage) => void;
+    };
+    static readonly type = "[AI Model] Create Model Client";
+    constructor(copilotModel: ICopilotModel, options: {
+        abortController?: AbortController;
+        usageCallback: (tokens: ILLMUsage) => void;
+    });
+}

package/src/lib/ai-model/commands/index.d.ts

@@ -0,0 +1 @@
+export * from './create-model-client.command';

package/src/lib/ai-model/index.d.ts

@@ -7,3 +7,4 @@ export * from './llm';
 export * from './errors';
 export * from './openai-compatible';
 export * from './utils/index';
+export * from './commands/index';

package/src/lib/ai-model/types/index.d.ts

@@ -3,6 +3,7 @@ export * from './rerank';
 export * from './model';
 export * from './speech2text';
 export * from './tts';
+export * from './profile';
 export declare const PROVIDE_AI_MODEL_LLM = "provide_ai_model_llm";
 export declare const PROVIDE_AI_MODEL_MODERATION = "provide_ai_model_moderation";
 export declare const PROVIDE_AI_MODEL_SPEECH2TEXT = "provide_ai_model_speech2text";

package/src/lib/ai-model/types/model.d.ts

@@ -1,5 +1,5 @@
 import { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import { AIModelEntity, ICopilot, ICopilotModel, ILLMUsage, ParameterType } from "@metad/contracts";
+import { AIModelEntity, ICopilot, ICopilotModel, ILLMUsage, ParameterType, PriceInfo, PriceType } from "@metad/contracts";
 export type TChatModelOptions = {
     modelProperties: Record<string, any>;
     handleLLMTokens: (input: {
@@ -17,6 +17,7 @@ export interface IAIModel {
     validateCredentials(model: string, credentials: Record<string, any>): Promise<void>;
     getChatModel(copilotModel: ICopilotModel, options?: TChatModelOptions): BaseChatModel;
     predefinedModels(): AIModelEntity[];
+    getPrice(model: string, credentials: Record<string, any>, priceType: PriceType, tokens: number): PriceInfo;
 }
 export declare const CommonParameterRules: {
     name: string;

package/src/lib/ai-model/types/profile.d.ts

@@ -0,0 +1,172 @@
+/**
+ * @deprecated Migrate to langchain v1
+ *
+ * Represents the capabilities and constraints of a language model.
+ *
+ * This interface defines the various features and limitations that a model may have,
+ * including input/output constraints, multimodal support, and advanced capabilities
+ * like tool calling and structured output.
+ */
+export interface ModelProfile {
+    /**
+     * Maximum number of tokens that can be included in the input context window.
+     *
+     * This represents the total token budget for the model's input, including
+     * the prompt, system messages, conversation history, and any other context.
+     *
+     * @example
+     * ```typescript
+     * const profile: ModelProfile = {
+     *   maxInputTokens: 128000 // Model supports up to 128k tokens
+     * };
+     * ```
+     */
+    maxInputTokens?: number;
+    /**
+     * Whether the model supports image inputs.
+     *
+     * When `true`, the model can process images as part of its input, enabling
+     * multimodal interactions where visual content can be analyzed alongside text.
+     *
+     * @see {@link imageUrlInputs} for URL-based image input support
+     */
+    imageInputs?: boolean;
+    /**
+     * Whether the model supports image URL inputs.
+     *
+     * When `true`, the model can accept URLs pointing to images rather than
+     * requiring the image data to be embedded directly in the request. This can
+     * be more efficient for large images or when images are already hosted.
+     *
+     * @see {@link imageInputs} for direct image input support
+     */
+    imageUrlInputs?: boolean;
+    /**
+     * Whether the model supports PDF document inputs.
+     *
+     * When `true`, the model can process PDF files as input, allowing it to
+     * analyze document content, extract information, or answer questions about
+     * PDF documents.
+     */
+    pdfInputs?: boolean;
+    /**
+     * Whether the model supports audio inputs.
+     *
+     * When `true`, the model can process audio data as input, enabling
+     * capabilities like speech recognition, audio analysis, or multimodal
+     * interactions involving sound.
+     */
+    audioInputs?: boolean;
+    /**
+     * Whether the model supports video inputs.
+     *
+     * When `true`, the model can process video data as input, enabling
+     * capabilities like video analysis, scene understanding, or multimodal
+     * interactions involving moving images.
+     */
+    videoInputs?: boolean;
+    /**
+     * Whether the model supports image content in tool messages.
+     *
+     * When `true`, tool responses can include images that the model can process
+     * and reason about. This enables workflows where tools return visual data
+     * that the model needs to interpret.
+     */
+    imageToolMessage?: boolean;
+    /**
+     * Whether the model supports PDF content in tool messages.
+     *
+     * When `true`, tool responses can include PDF documents that the model can
+     * process and reason about. This enables workflows where tools return
+     * document data that the model needs to interpret.
+     */
+    pdfToolMessage?: boolean;
+    /**
+     * Maximum number of tokens the model can generate in its output.
+     *
+     * This represents the upper limit on the length of the model's response.
+     * The actual output may be shorter depending on the completion criteria
+     * (e.g., natural stopping point, stop sequences).
+     *
+     * @example
+     * ```typescript
+     * const profile: ModelProfile = {
+     *   maxOutputTokens: 4096 // Model can generate up to 4k tokens
+     * };
+     * ```
+     */
+    maxOutputTokens?: number;
+    /**
+     * Whether the model supports reasoning or chain-of-thought output.
+     *
+     * When `true`, the model can produce explicit reasoning steps or
+     * chain-of-thought explanations as part of its output. This is useful
+     * for understanding the model's decision-making process and improving
+     * transparency in complex reasoning tasks.
+     */
+    reasoningOutput?: boolean;
+    /**
+     * Whether the model can generate image outputs.
+     *
+     * When `true`, the model can produce images as part of its response,
+     * enabling capabilities like image generation, editing, or visual
+     * content creation.
+     */
+    imageOutputs?: boolean;
+    /**
+     * Whether the model can generate audio outputs.
+     *
+     * When `true`, the model can produce audio data as part of its response,
+     * enabling capabilities like text-to-speech, audio generation, or
+     * sound synthesis.
+     */
+    audioOutputs?: boolean;
+    /**
+     * Whether the model can generate video outputs.
+     *
+     * When `true`, the model can produce video data as part of its response,
+     * enabling capabilities like video generation, editing, or visual
+     * content creation with motion.
+     */
+    videoOutputs?: boolean;
+    /**
+     * Whether the model supports tool calling (function calling).
+     *
+     * When `true`, the model can invoke external tools or functions during
+     * its reasoning process. The model can decide which tools to call,
+     * with what arguments, and can incorporate the tool results into its
+     * final response.
+     *
+     * @see {@link toolChoice} for controlling tool selection behavior
+     * @see {@link https://docs.langchain.com/oss/javascript/langchain/models#tool-calling}
+     */
+    toolCalling?: boolean;
+    /**
+     * Whether the model supports tool choice control.
+     *
+     * When `true`, the caller can specify how the model should select tools,
+     * such as forcing the use of a specific tool, allowing any tool, or
+     * preventing tool use entirely. This provides fine-grained control over
+     * the model's tool-calling behavior.
+     *
+     * @see {@link toolCalling} for basic tool calling support
+     */
+    toolChoice?: boolean;
+    /**
+     * Whether the model supports structured output generation.
+     *
+     * When `true`, the model can generate responses that conform to a
+     * specified schema or structure (e.g., JSON with a particular format).
+     * This is useful for ensuring the model's output can be reliably parsed
+     * and processed programmatically.
+     *
+     * @example
+     * ```typescript
+     * // Model can be instructed to return JSON matching a schema
+     * const profile: ModelProfile = {
+     *   structuredOutput: true
+     * };
+     * ```
+     */
+    structuredOutput?: boolean;
+}

package/src/lib/core/index.d.ts

@@ -4,3 +4,5 @@ export * from './schema';
 export * from './i18n';
 export * from './utils';
 export * from './context/index';
+export * from './types';
+export * from './strategy-bus';

package/src/lib/core/strategy-bus.d.ts

@@ -0,0 +1,17 @@
+import { StrategyEntry } from './types';
+export type StrategyBusEvent<S = any> = {
+    type: 'UPSERT';
+    strategyType: string;
+    entry: StrategyEntry<S>;
+} | {
+    type: 'REMOVE';
+    strategyType?: string;
+    pluginName: string;
+    orgId: string;
+};
+export declare class StrategyBus {
+    private readonly subject;
+    readonly events$: import("rxjs").Observable<StrategyBusEvent<any>>;
+    upsert<S>(strategyType: string, entry: StrategyEntry<S>): void;
+    remove(orgId: string, pluginName: string): void;
+}