chat - 聊天模型的接口及字典

solon-ai 旨在提供一套通用的访问接口（通过方言适配）。可兼容各种不同的大模型接口。

1、聊天模型（ChatModel）相关的接口

2、四种聊天消息（ChatMessage）

3、主要接口字典

• ChatModel

public class ChatModel implements AiModel {
    private final ChatConfig config;
    private final ChatDialect dialect;

    public ChatModel(Properties properties) {
        //支持直接注入
        this(Props.from(properties).bindTo(new ChatConfig()));
    }

    public ChatModel(ChatConfig config) {
        Assert.notNull(config, "The config is required");
        Assert.notNull(config.getApiUrl(), "The config.apiUrl is required");
        Assert.notNull(config.getModel(), "The config.model is required");

        this.config = config;
        this.dialect = ChatDialectManager.select(config);

        Assert.notNull(dialect, "The dialect(provider) no matched, check config or dependencies");

    }

    /**
     * 提示语
     *
     * @deprecated 3.8.4 {@link ChatRequestDesc#session(ChatSession)}
     */
    @Deprecated
    public ChatRequestDesc prompt(ChatSession session) {
        return new ChatRequestDescDefault(config, dialect, session, null);
    }

    /**
     * 提示语
     */
    public ChatRequestDesc prompt(Prompt prompt) {
        return new ChatRequestDescDefault(config, dialect, null, prompt);
    }

    /**
     * 提示语
     */
    public ChatRequestDesc prompt(List<ChatMessage> messages) {
        return prompt(Prompt.of(messages));
    }

    /**
     * 提示语
     */
    public ChatRequestDesc prompt(ChatMessage... messages) {
        return prompt(Utils.asList(messages));
    }

    /**
     * 提示语
     */
    public ChatRequestDesc prompt(String content) {
        return prompt(ChatMessage.ofUser(content));
    }


    @Override
    public String toString() {
        return "ChatModel{" +
                "config=" + config +
                ", dialect=" + dialect.getClass().getName() +
                '}';
    }


    /// /////////////////////////////////

    /**
     * 构建
     */
    public static Builder of(ChatConfig config) {
        return new Builder(config);
    }

    /**
     * 开始构建
     */
    public static Builder of(String apiUrl) {
        return new Builder(apiUrl);
    }

    /// //////////////////

    /**
     * 聊天模型构建器实现
     *
     * @author noear
     * @since 3.1
     */
    public static class Builder {
        private final ChatConfig config;

        /**
         * @param apiUrl 接口地址
         */
        public Builder(String apiUrl) {
            this.config = new ChatConfig();
            this.config.setApiUrl(apiUrl);
        }

        /**
         * @param config 配置
         */
        public Builder(ChatConfig config) {
            this.config = config;
        }

        /**
         * 接口密钥
         */
        public Builder apiKey(String apiKey) {
            config.setApiKey(apiKey);
            return this;
        }

        /**
         * 服务提供者
         */
        public Builder provider(String provider) {
            config.setProvider(provider);
            return this;
        }

        /**
         * 使用模型
         */
        public Builder model(String model) {
            config.setModel(model);
            return this;
        }

        /**
         * 头信息添加
         */
        public Builder headerSet(String key, String value) {
            config.setHeader(key, value);
            return this;
        }

        public Builder modelOptions(Consumer<ModelOptionsAmend<?, ChatInterceptor>> consumer) {
            consumer.accept(config.getModelOptions());
            return this;
        }

        /**
         * 默认工具添加（即每次请求都会带上）
         *
         * @param tool 工具对象
         */
        public Builder defaultToolAdd(FunctionTool tool) {
            config.addDefaultTool(tool);
            return this;
        }

        /**
         * 默认工具添加（即每次请求都会带上）
         *
         * @param toolColl 工具集合
         */
        public Builder defaultToolAdd(Iterable<FunctionTool> toolColl) {
            for (FunctionTool f : toolColl) {
                config.addDefaultTool(f);
            }

            return this;
        }

        /**
         * 默认工具添加（即每次请求都会带上）
         *
         * @param toolProvider 工具提供者
         */
        public Builder defaultToolAdd(ToolProvider toolProvider) {
            return defaultToolAdd(toolProvider.getTools());
        }

        /**
         * 默认工具添加（即每次请求都会带上）
         *
         * @param toolObj 工具对象
         */
        public Builder defaultToolAdd(Object toolObj) {
            return defaultToolAdd(new MethodToolProvider(toolObj));
        }

        /**
         * 默认工具添加（即每次请求都会带上）
         *
         * @param name        名字
         * @param toolBuilder 工具构建器
         */
        public Builder defaultToolAdd(String name, Consumer<FunctionToolDesc> toolBuilder) {
            FunctionToolDesc decl = new FunctionToolDesc(name);
            toolBuilder.accept(decl);
            config.addDefaultTool(decl);
            return this;
        }


        /**
         * 默认技能添加
         *
         * @since 3.8.4
         */
        public Builder defaultSkillAdd(Skill skill) {
            return defaultSkillAdd(0, skill);
        }

        /**
         * 默认技能添加
         *
         * @since 3.8.4
         */
        public Builder defaultSkillAdd(int index, Skill skill) {
            config.addDefaultSkill(index, skill);
            return this;
        }

        /**
         * 添加默认拦截器
         *
         * @param interceptor 拦截器
         */
        public Builder defaultInterceptorAdd(ChatInterceptor interceptor) {
            return defaultInterceptorAdd(0, interceptor);
        }

        /**
         * 添加默认拦截器
         *
         * @param index       顺序位
         * @param interceptor 拦截器
         */
        public Builder defaultInterceptorAdd(int index, ChatInterceptor interceptor) {
            config.addDefaultInterceptor(index, interceptor);
            return this;
        }

        /**
         * 网络超时
         */
        public Builder timeout(Duration timeout) {
            config.setTimeout(timeout);

            return this;
        }

        /**
         * 网络代理
         */
        public Builder proxy(Proxy proxy) {
            config.setProxy(proxy);

            return this;
        }

        /**
         * 网络代理
         */
        public Builder proxy(String host, int port) {
            return proxy(new Proxy(Proxy.Type.HTTP, new InetSocketAddress(host, port)));
        }

        /**
         * 构建
         */
        public ChatModel build() {
            return new ChatModel(config);
        }

        //----------------

        /**
         * 添加默认选项
         *
         * @deprecated 3.8.4 {@link #modelOptions(Consumer)}
         */
        @Deprecated
        public Builder defaultOptionAdd(String key, Object val) {
            config.addDefaultOption(key, val);
            return this;
        }


        /**
         * 默认工具添加（即每次请求都会带上）
         *
         * @param tool 工具对象
         * @deprecated 3.8.4 {@link #defaultToolAdd(FunctionTool)}
         */
        @Deprecated
        public Builder defaultToolsAdd(FunctionTool tool) {
            return defaultToolAdd(tool);
        }

        /**
         * 默认工具添加（即每次请求都会带上）
         *
         * @param toolColl 工具集合
         * @deprecated 3.8.4 {@link #defaultToolAdd(Iterable)}
         */
        @Deprecated
        public Builder defaultToolsAdd(Iterable<FunctionTool> toolColl) {
            return defaultToolAdd(toolColl);
        }

        /**
         * 默认工具添加（即每次请求都会带上）
         *
         * @param toolProvider 工具提供者
         * @deprecated 3.8.4 {@link #defaultToolAdd(ToolProvider)}
         */
        @Deprecated
        public Builder defaultToolsAdd(ToolProvider toolProvider) {
            return defaultToolAdd(toolProvider.getTools());
        }

        /**
         * 默认工具添加（即每次请求都会带上）
         *
         * @param toolObj 工具对象
         * @deprecated 3.8.4 {@link #defaultToolAdd(Object)}
         */
        @Deprecated
        public Builder defaultToolsAdd(Object toolObj) {
            return defaultToolAdd(toolObj);
        }

        /**
         * 默认工具添加（即每次请求都会带上）
         *
         * @param name        名字
         * @param toolBuilder 工具构建器
         * @deprecated 3.8.4 {@link #defaultToolAdd(String, Consumer)}
         */
        @Deprecated
        public Builder defaultToolsAdd(String name, Consumer<FunctionToolDesc> toolBuilder) {
            return defaultToolAdd(name, toolBuilder);
        }


        /**
         * 默认工具上下文添加
         *
         * @deprecated 3.8.4 {@link #modelOptions(Consumer)}
         */
        @Deprecated
        public Builder defaultToolsContextAdd(String key, Object value) {
            config.getModelOptions().toolContextPut(key, value);
            return this;
        }

        /**
         * 默认工具上下文添加
         *
         * @deprecated 3.8.4 {@link #modelOptions(Consumer)}
         */
        @Deprecated
        public Builder defaultToolsContextAdd(Map<String, Object> map) {
            config.getModelOptions().toolContextPut(map);
            return this;
        }
    }
}

• ChatRequestDesc（聊天请求声明）

public interface ChatRequestDesc {
    /**
     * 会话设置
     *
     * @param session 会话
     * @since 3.8.4
     */
    ChatRequestDesc session(ChatSession session);

    /**
     * 选项设置
     *
     * @param options 选项
     */
    ChatRequestDesc options(ChatOptions options);

    /**
     * 选项配置
     *
     * @param optionsBuilder 选项构建器
     */
    ChatRequestDesc options(Consumer<ChatOptions> optionsBuilder);

    /**
     * 调用
     */
    ChatResponse call() throws IOException;

    /**
     * 流响应
     */
    Publisher<ChatResponse> stream();
}

• ChatDialect（可以自己扩展适配，增加不同方言支持）

public interface ChatDialect extends AiModelDialect {
    /**
     * 是否为默认
     */
    default boolean isDefault() {
        return false;
    }

    /**
     * 匹配检测
     *
     * @param config 聊天配置
     */
    boolean matched(ChatConfig config);

    /**
     * 创建 http 工具
     *
     * @param config 聊天配置
     */
    HttpUtils createHttpUtils(ChatConfig config);

    /**
     * 创建 http 工具
     *
     * @param config   聊天配置
     * @param isStream 是否流式获取
     */
    default HttpUtils createHttpUtils(ChatConfig config, boolean isStream) {
        return createHttpUtils(config);
    }

    /**
     * 构建请求数据
     *
     * @param config   聊天配置
     * @param options  聊天选项
     * @param messages 消息
     * @param isStream 是否流式获取
     */
    String buildRequestJson(ChatConfig config, ChatOptions options, List<ChatMessage> messages, boolean isStream);

    /**
     * 构建助理消息节点
     *
     * @param toolCallBuilders 工具调用构建器集合
     */
    ONode buildAssistantMessageNode(Map<String, ToolCallBuilder> toolCallBuilders);

    /**
     * 构建助理消息根据直接返回的工具消息
     *
     * @param toolMessages 直接返回的工具消息
     */
    AssistantMessage buildAssistantMessageByToolMessages(List<ToolMessage> toolMessages);

    /**
     * 分析响应数据
     *
     * @param config   聊天配置
     * @param resp     响应体
     * @param respJson 响应数据
     */
    boolean parseResponseJson(ChatConfig config, ChatResponseDefault resp, String respJson);

    /**
     * 分析工具调用
     *
     * @param resp     响应体
     * @param oMessage 消息节点
     */
    List<AssistantMessage> parseAssistantMessage(ChatResponseDefault resp, ONode oMessage);
}