ai-client-kit/dist/utils/agent.d.ts

一款 AI 集成套件，适配任意前端框架，兼容多种大模型、聊天面板、Function Calling、Agent、工作流等。

/**
 * Copyright 2025 Hughe5
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import Ajv from 'ajv';
declare function abort(): void;
interface StringParameter {
    type: 'string';
    description?: string;
    enum?: string[];
    pattern?: string;
    format?: string;
    default?: string;
    minLength?: number;
    maxLength?: number;
}
interface NumberParameter {
    type: 'number' | 'integer';
    description?: string;
    enum?: number[];
    minimum?: number;
    maximum?: number;
    default?: number;
    exclusiveMinimum?: number;
    exclusiveMaximum?: number;
    multipleOf?: number;
}
interface BooleanParameter {
    type: 'boolean';
    description?: string;
    default?: boolean;
}
interface ArrayParameter {
    type: 'array';
    description?: string;
    items: Parameters;
    minItems?: number;
    maxItems?: number;
    uniqueItems?: boolean;
    default?: unknown[];
}
interface ObjectParameter {
    type: 'object';
    description?: string;
    properties: Record<string, Parameters>;
    required?: string[];
    default?: Record<string, unknown>;
    additionalProperties?: boolean;
}
type Parameters = StringParameter | NumberParameter | BooleanParameter | ArrayParameter | ObjectParameter;
type DefinitionType = 'function';
interface Definition {
    type: DefinitionType;
    function: {
        name: string;
        description: string;
        parameters: Extract<Parameters, {
            type: 'object';
        }>;
    };
}
type ParamType<T extends Parameters> = T extends {
    type: 'string';
} ? string : T extends {
    type: 'number' | 'integer';
} ? number : T extends {
    type: 'boolean';
} ? boolean : T extends {
    type: 'array';
    items: infer I;
} ? I extends Parameters ? ParamType<I>[] : never : T extends {
    type: 'object';
    properties: infer P;
    required?: infer R;
} ? RequiredKeys<P extends Record<string, Parameters> ? P : never, R extends readonly string[] | undefined ? R : undefined> : never;
type RequiredKeysWithRequired<P extends Record<string, Parameters>, R extends string[]> = {
    [K in Extract<keyof P, R[number]>]: ParamType<P[K]>;
} & {
    [K in Exclude<keyof P, R[number]>]?: ParamType<P[K]>;
};
type RequiredKeysNoRequired<P extends Record<string, Parameters>> = {
    [K in keyof P]?: ParamType<P[K]>;
};
type RequiredKeys<P extends Record<string, Parameters>, R extends readonly string[] | undefined> = R extends string[] ? RequiredKeysWithRequired<P, R> : RequiredKeysNoRequired<P>;
type Args<T extends Definition> = ParamType<T['function']['parameters']>;
type Handler<T extends Definition> = (args: Args<T>) => string | Promise<string>;
type Tool<T extends Definition = Definition> = {
    def: T;
    handler: Handler<T>;
};
declare class ToolManager {
    protected tools: Record<string, Tool>;
    protected ajv: Ajv;
    private validatorCache;
    register<T extends Definition>(def: T, handler: Handler<T>): void;
    getDefinition(name: string): Definition;
    getHandler(name: string): Handler<Definition>;
    remove(name: string): void;
    get definitions(): Definition[];
    getDefinitions(names: string[]): Definition[];
    private getValidator;
    validate(name: string, args: unknown): boolean;
    call<T extends Definition>(name: string, args: Args<T>): Promise<string>;
}
interface Config {
    model: string;
    url: string;
    systemMessageContent?: string;
    maxRounds?: number;
}
type ToolCall = {
    id: string;
    function: {
        name: string;
        arguments: string;
    };
};
interface SimpleMessage {
    role: 'system' | 'user';
    content: string;
}
interface AssistantMessage {
    role: 'assistant';
    content: string;
    reasoning_content?: string;
    tool_calls?: ToolCall[] | null;
}
interface ToolMessage {
    role: 'tool';
    content: string;
    tool_call_id: string;
}
type Message = SimpleMessage | AssistantMessage | ToolMessage;
interface Params {
    tools?: string[];
    roundsLeft?: number;
}
interface Chunk {
    choices: Array<{
        delta: AssistantMessage;
    }>;
}
type StreamResult = AsyncGenerator<Chunk, AssistantMessage | StreamResult | undefined, void>;
declare class Agent extends ToolManager {
    model: string;
    url: string;
    messages: Message[];
    maxRounds: number;
    defaultParams: Params;
    constructor(config: Config);
    pushMessage(message: Message): void;
    pushMessages(messages: Message[]): void;
    merge<T extends object, S extends object>(target: T | null, source: S, fieldsToConcat?: (keyof (T & S))[]): T & S;
    invoke(params?: Params): Promise<AssistantMessage | undefined>;
    invokeStream(params?: Params): StreamResult;
}
export { type Parameters, type Definition, type Args, type Handler, type Message, type AssistantMessage, type StreamResult, abort, ToolManager, Agent, };