Merge branch 'main' into oidc

This commit is contained in:
Windfarer
2026-03-30 11:31:28 +08:00
committed by GitHub
34 changed files with 1353 additions and 285 deletions
+1
View File
@@ -187,6 +187,7 @@ export interface IMChannel {
enabled: boolean;
mode: 'webhook' | 'websocket';
output_mode: 'stream' | 'full';
session_mode?: 'user' | 'thread';
knowledge_base_id?: string;
credentials: Record<string, any>;
created_at?: string;
@@ -37,6 +37,10 @@
<t-icon name="play-circle" class="meta-icon" />
{{ channel.output_mode === 'stream' ? $t('agentEditor.im.outputStream') : $t('agentEditor.im.outputFull') }}
</span>
<span v-if="channel.session_mode === 'thread'" class="meta-tag">
<t-icon name="chat" class="meta-icon" />
{{ $t('agentEditor.im.sessionModeThread') }}
</span>
</div>
<div v-if="channel.mode === 'webhook'" class="callback-url-row">
<span class="url-label">{{ $t('agentEditor.im.callbackUrl') }}:</span>
@@ -121,6 +125,19 @@
</t-radio-group>
</div>
<!-- Session Mode -->
<div class="form-item">
<label class="form-label">{{ $t('agentEditor.im.sessionMode') }}</label>
<t-radio-group v-model="formData.session_mode">
<t-radio-button value="user">{{ $t('agentEditor.im.sessionModeUser') }}</t-radio-button>
<t-radio-button value="thread"
:disabled="!platformSupportsThread(formData.platform)">
{{ $t('agentEditor.im.sessionModeThread') }}
</t-radio-button>
</t-radio-group>
<p class="form-hint">{{ $t('agentEditor.im.sessionModeHint') }}</p>
</div>
<!-- Knowledge base for file messages -->
<div class="form-item">
<label class="form-label">{{ $t('agentEditor.im.fileKnowledgeBase') }}</label>
@@ -356,6 +373,7 @@ const formData = ref({
name: '',
mode: 'websocket' as 'webhook' | 'websocket',
output_mode: 'stream' as 'stream' | 'full',
session_mode: 'user' as 'user' | 'thread',
knowledge_base_id: '',
credentials: defaultCredentials(),
});
@@ -365,6 +383,10 @@ function platformLabel(platform: string): string {
return t(key);
}
function platformSupportsThread(platform: string): boolean {
return ['slack', 'mattermost', 'feishu', 'telegram'].includes(platform);
}
watch(
() => formData.value.platform,
(p) => {
@@ -374,6 +396,9 @@ watch(
formData.value.credentials.post_to_main = false;
}
}
if (!platformSupportsThread(p)) {
formData.value.session_mode = 'user';
}
},
);
@@ -427,6 +452,7 @@ function editChannel(channel: IMChannel) {
name: channel.name,
mode: channel.mode,
output_mode: channel.output_mode,
session_mode: channel.session_mode || 'user',
knowledge_base_id: channel.knowledge_base_id || '',
credentials: { ...channel.credentials },
};
@@ -440,6 +466,7 @@ function resetForm() {
name: '',
mode: 'websocket',
output_mode: 'stream',
session_mode: 'user',
knowledge_base_id: '',
credentials: defaultCredentials(),
};
@@ -452,6 +479,7 @@ async function handleSave() {
name: formData.value.name,
mode: formData.value.mode,
output_mode: formData.value.output_mode,
session_mode: formData.value.session_mode,
knowledge_base_id: formData.value.knowledge_base_id,
credentials: formData.value.credentials,
});
@@ -462,6 +490,7 @@ async function handleSave() {
name: formData.value.name,
mode: formData.value.mode,
output_mode: formData.value.output_mode,
session_mode: formData.value.session_mode,
knowledge_base_id: formData.value.knowledge_base_id,
credentials: formData.value.credentials,
});
@@ -373,7 +373,7 @@ const fallbackProviderOptions = computed(() => [
value: 'nvidia',
label: t('model.editor.providers.nvidia.label'),
defaultUrls: {
chat: 'https://integrate.api.nvidia.com/v1/chat/completions',
chat: 'https://integrate.api.nvidia.com/v1',
embedding: 'https://integrate.api.nvidia.com/v1',
rerank: 'https://ai.api.nvidia.com/v1/retrieval/nvidia/reranking',
vllm: 'https://integrate.api.nvidia.com/v1',
+4
View File
@@ -3252,6 +3252,10 @@ export default {
fileKnowledgeBase: 'File Storage Knowledge Base',
fileKnowledgeBasePlaceholder: 'Select a knowledge base (optional)',
fileKnowledgeBaseHint: 'When configured, files sent by users will be automatically saved to this knowledge base',
sessionMode: 'Session Mode',
sessionModeUser: 'Per User (default)',
sessionModeThread: 'Per Thread',
sessionModeHint: 'User mode: each person has their own conversation. Use /clear to start fresh. Thread mode: each message thread is a separate conversation. Multiple people can collaborate in the same thread.',
},
mcp: {
label: 'MCP Services',
+4
View File
@@ -3275,6 +3275,10 @@ export default {
fileKnowledgeBase: "파일 저장 지식 베이스",
fileKnowledgeBasePlaceholder: "지식 베이스 선택 (선택 사항)",
fileKnowledgeBaseHint: "설정 시 사용자가 보낸 파일이 자동으로 해당 지식 베이스에 저장됩니다",
sessionMode: "세션 모드",
sessionModeUser: "사용자별 (기본)",
sessionModeThread: "스레드별",
sessionModeHint: "사용자 모드: 각 사용자별 독립 대화. /clear로 새 대화 시작. 스레드 모드: 메시지 스레드별 독립 대화. 같은 스레드에서 여러 명이 함께 대화 가능.",
},
tools: {
thinking: '사고',
+4
View File
@@ -2914,6 +2914,10 @@ export default {
fileKnowledgeBase: 'База знаний для файлов',
fileKnowledgeBasePlaceholder: 'Выберите базу знаний (необязательно)',
fileKnowledgeBaseHint: 'При настройке файлы, отправленные пользователями, автоматически сохраняются в эту базу знаний',
sessionMode: 'Режим сессии',
sessionModeUser: 'По пользователю (по умолчанию)',
sessionModeThread: 'По потоку',
sessionModeHint: 'Режим пользователя: отдельный диалог для каждого пользователя. /clear для нового диалога. Режим потока: отдельный диалог для каждого потока. Несколько человек могут общаться в одном потоке.',
},
mcp: {
label: 'MCP-сервисы',
+4
View File
@@ -3227,6 +3227,10 @@ export default {
fileKnowledgeBase: "文件保存知识库",
fileKnowledgeBasePlaceholder: "选择知识库(可选)",
fileKnowledgeBaseHint: "配置后,用户发送的文件将自动保存到该知识库中",
sessionMode: "会话模式",
sessionModeUser: "按用户(默认)",
sessionModeThread: "按话题",
sessionModeHint: "用户模式:每个用户独立对话,使用 /clear 开始新对话。话题模式:每个消息话题独立对话,同一话题中多人可协作。",
},
tools: {
thinking: "思考",
+43 -56
View File
@@ -1,5 +1,10 @@
import mermaid from 'mermaid';
import type {Tokens} from 'marked';
import {openMermaidFullscreen} from "@/utils/mermaidViewer.ts";
import hljs from "highlight.js";
import "highlight.js/styles/github.css";
hljs.registerAliases("mermaid", { languageName: "plaintext" });
let mermaidInitialized = false;
@@ -37,73 +42,55 @@ export const ensureMermaidInitialized = () => {
mermaidInitialized = true;
};
let mermaidCount = 0;
export const createMermaidCodeRenderer = (idPrefix: string) => {
let mermaidCount = 0;
return ({text, lang}: Tokens.Code) => {
let highlighted = '';
let highlightLang: string = lang || 'Code';
if (highlightLang && hljs.getLanguage(highlightLang)) {
try {
highlighted = hljs.highlight(text, { language: lang }).value;
} catch {
let ret = hljs.highlightAuto(text);
highlighted = ret.value;
highlightLang = ret.language || "Code";
}
} else {
let ret = hljs.highlightAuto(text);
highlighted = ret.value;
highlightLang = ret.language || "Code";
}
if (lang === 'mermaid') {
const id = `${idPrefix}-${++mermaidCount}`;
return `<div class="mermaid" id="${id}">${text}</div>`;
return `<pre id="${id}" data-mermaid="false"><code class="hljs language-${highlightLang}">${highlighted}</code></pre>`;
}
const displayLang = lang || 'Code';
const escapedCode = text
.replace(/&/g, '&amp;')
.replace(/</g, '&lt;')
.replace(/>/g, '&gt;');
return `<pre><code class="language-${displayLang}">${escapedCode}</code></pre>`;
return `<pre><code class="hljs language-${highlightLang}">${highlighted}</code></pre>`;
};
};
export const renderMermaidInContainer = async (
rootElement: HTMLElement | null | undefined,
renderedMermaidIds: Set<string>,
) => {
if (!rootElement) return 0;
const mermaidElements = rootElement.querySelectorAll<HTMLElement>('.mermaid');
const unrenderedElements: HTMLElement[] = [];
mermaidElements.forEach((el) => {
const id = el.id || `mermaid-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
if (!el.id) {
el.id = id;
const mermaidElements = rootElement.querySelectorAll<HTMLElement>('pre[data-mermaid="false"]');
for (const el of mermaidElements) {
try{
const code = el.innerText;
// 验证
await mermaid.parse(code);
// 渲染
let {svg} = await mermaid.render(`${el.id}-svg`, code);
el.classList.add('mermaid')
el.innerHTML = svg;
el.onclick = (event) => {
event.stopPropagation();
openMermaidFullscreen(svg);
};
} catch(e){
console.error("Mermaid rendering error:", e);
}
if (!renderedMermaidIds.has(el.id) && !el.querySelector('svg')) {
renderedMermaidIds.add(el.id);
unrenderedElements.push(el);
}
});
if (unrenderedElements.length === 0) return 0;
await mermaid.run({ nodes: unrenderedElements });
return unrenderedElements.length;
};
export const bindMermaidFullscreenEvents = (
rootElement: HTMLElement | null | undefined,
onOpenFullscreen: (svgOuterHTML: string) => void,
) => {
if (!rootElement) return;
const mermaidDivs = rootElement.querySelectorAll<HTMLElement>('.mermaid');
mermaidDivs.forEach((div) => {
div.style.cursor = 'pointer';
const oldHandler = (div as any).__mermaidClickHandler as EventListener | undefined;
if (oldHandler) {
div.removeEventListener('click', oldHandler);
}
const handler: EventListener = (e: Event) => {
e.stopPropagation();
const target = e.currentTarget as HTMLElement;
const svg = target.querySelector('svg');
if (svg) {
onOpenFullscreen(svg.outerHTML);
}
};
(div as any).__mermaidClickHandler = handler;
div.addEventListener('click', handler);
});
};
// 标记为已渲染
el.setAttribute('data-mermaid', 'true');
}
};
@@ -349,7 +349,6 @@ import { MessagePlugin } from 'tdesign-vue-next';
import { useUIStore } from '@/stores/ui';
import { useI18n } from 'vue-i18n';
import i18n from '@/i18n';
import { openMermaidFullscreen } from '@/utils/mermaidViewer';
import { hydrateProtectedFileImages } from '@/utils/security';
import {
buildManualMarkdown,
@@ -358,7 +357,6 @@ import {
replaceIncompleteImageWithPlaceholder,
} from '@/utils/chatMessageShared';
import {
bindMermaidFullscreenEvents,
createMermaidCodeRenderer,
ensureMermaidInitialized,
renderMermaidInContainer,
@@ -1466,28 +1464,9 @@ const protectProviderImageSrcInHTML = (html: string): string => {
);
};
// 已渲染的 mermaid 元素 ID 集合
const renderedMermaidIds = new Set<string>();
// 渲染 Mermaid 图表的函数
const renderMermaidDiagrams = async () => {
try {
const renderedCount = await renderMermaidInContainer(rootElement.value, renderedMermaidIds);
if (renderedCount > 0) {
nextTick(() => {
bindMermaidClickEvents();
});
}
} catch (error) {
console.error('Mermaid rendering error:', error);
}
};
// 为 Mermaid 容器绑定点击全屏事件(绑定在 div 上,不是 SVG 上)
const bindMermaidClickEvents = () => {
bindMermaidFullscreenEvents(rootElement.value, (svgOuterHTML: string) => {
openMermaidFullscreen(svgOuterHTML);
});
await renderMermaidInContainer(rootElement.value);
};
// Tool summary - extract key info to display externally
+5 -26
View File
@@ -60,14 +60,13 @@
</div>
</template>
<script setup>
import { onMounted, onBeforeUnmount, watch, computed, ref, reactive, defineProps, nextTick } from 'vue';
import { onMounted, onBeforeUnmount, watch, computed, ref, reactive, defineProps, nextTick, onUpdated } from 'vue';
import { marked } from 'marked';
import docInfo from './docInfo.vue';
import deepThink from './deepThink.vue';
import AgentStreamDisplay from './AgentStreamDisplay.vue';
import picturePreview from '@/components/picture-preview.vue';
import { sanitizeHTML, safeMarkdownToHTML, createSafeImage, isValidImageURL, hydrateProtectedFileImages } from '@/utils/security';
import { openMermaidFullscreen } from '@/utils/mermaidViewer';
import { useI18n } from 'vue-i18n';
import { MessagePlugin } from 'tdesign-vue-next';
import { useUIStore } from '@/stores/ui';
@@ -78,7 +77,6 @@ import {
replaceIncompleteImageWithPlaceholder
} from '@/utils/chatMessageShared';
import {
bindMermaidFullscreenEvents,
createMermaidCodeRenderer,
ensureMermaidInitialized,
renderMermaidInContainer
@@ -228,7 +226,7 @@ const handleAddToKnowledge = () => {
const question = (props.userQuery || '').trim();
const manualContent = buildManualMarkdown(question, content);
const manualTitle = formatManualTitle(question);
``
uiStore.openManualEditor({
mode: 'create',
title: manualTitle,
@@ -254,30 +252,11 @@ const handleMarkdownImageClick = (e) => {
// 渲染 Mermaid 图表的函数
const renderMermaidDiagrams = async () => {
try {
const renderedCount = await renderMermaidInContainer(parentMd.value, renderedMermaidIds);
if (renderedCount > 0) {
nextTick(() => {
bindMermaidClickEvents();
});
}
} catch (error) {
console.error('Mermaid rendering error:', error);
}
};
// 已渲染的 mermaid 元素 ID 集合
const renderedMermaidIds = new Set();
// 为 Mermaid 容器绑定点击全屏事件(绑定在 div 上,不是 SVG 上)
const bindMermaidClickEvents = () => {
bindMermaidFullscreenEvents(parentMd.value, (svgOuterHTML) => {
openMermaidFullscreen(svgOuterHTML);
});
await renderMermaidInContainer(parentMd.value);
};
// 监听内容变化并渲染 Mermaid - 只在会话完成后渲染
watch(() => [props.content, props.session?.content, props.session?.is_completed], () => {
onUpdated(() => {
nextTick(async () => {
await hydrateProtectedFileImages(parentMd.value);
// 只在会话完成后渲染 mermaid
@@ -285,7 +264,7 @@ watch(() => [props.content, props.session?.content, props.session?.is_completed]
renderMermaidDiagrams();
}
});
}, { immediate: true });
});
onMounted(async () => {
// 为 markdown-content 中的图片添加点击事件
+224 -129
View File
@@ -4,6 +4,7 @@ import (
"context"
"encoding/json"
"fmt"
"sync"
"time"
agenttools "github.com/Tencent/WeKnora/internal/agent/tools"
@@ -11,6 +12,7 @@ import (
"github.com/Tencent/WeKnora/internal/event"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
"golang.org/x/sync/errgroup"
)
// toolDisplayNames maps internal tool names to user-friendly display labels.
@@ -62,6 +64,7 @@ func formatToolHint(name string, args map[string]any) string {
// executeToolCalls runs every tool call in the LLM response, appending results to step.ToolCalls.
// It also emits tool-call and tool-result events, and optionally runs reflection after each call.
// When ParallelToolCalls is enabled and there are 2+ tool calls, they execute concurrently.
func (e *AgentEngine) executeToolCalls(
ctx context.Context, response *types.ChatResponse,
step *types.AgentStep, iteration int, sessionID string,
@@ -71,165 +74,257 @@ func (e *AgentEngine) executeToolCalls(
}
round := iteration + 1
logger.Infof(ctx, "[Agent][Round-%d] Executing %d tool call(s)", round, len(response.ToolCalls))
n := len(response.ToolCalls)
logger.Infof(ctx, "[Agent][Round-%d] Executing %d tool call(s)", round, n)
// Use parallel execution when enabled and there are multiple tool calls
if e.config.ParallelToolCalls && n >= 2 {
e.executeToolCallsParallel(ctx, response, step, iteration, sessionID)
return
}
for i, tc := range response.ToolCalls {
// Normalize tool call ID for cross-provider compatibility
tc.ID = agenttools.NormalizeToolCallID(tc.ID, tc.Function.Name, i)
toolTag := fmt.Sprintf("[Agent][Round-%d][Tool %s (%d/%d)]",
round, tc.Function.Name, i+1, len(response.ToolCalls))
e.executeSingleToolCall(ctx, tc, i, step, iteration, round, sessionID)
}
}
var args map[string]any
argsStr := tc.Function.Arguments
if err := json.Unmarshal([]byte(argsStr), &args); err != nil {
// Attempt JSON repair before giving up
repaired := agenttools.RepairJSON(argsStr)
if repairErr := json.Unmarshal([]byte(repaired), &args); repairErr != nil {
logger.Errorf(ctx, "%s Failed to parse arguments (repair failed): %v", toolTag, err)
step.ToolCalls = append(step.ToolCalls, types.ToolCall{
ID: tc.ID,
Name: tc.Function.Name,
Args: map[string]any{"_raw": argsStr},
Result: &types.ToolResult{
Success: false,
Error: fmt.Sprintf(
"Failed to parse tool arguments: %v", err,
) + "\n\n[Analyze the error above and try a different approach.]",
},
})
continue
}
logger.Warnf(ctx, "%s Repaired malformed JSON arguments", toolTag)
tc.Function.Arguments = repaired
}
// executeToolCallsParallel runs all tool calls concurrently using errgroup,
// collecting results in original order.
func (e *AgentEngine) executeToolCallsParallel(
ctx context.Context, response *types.ChatResponse,
step *types.AgentStep, iteration int, sessionID string,
) {
round := iteration + 1
n := len(response.ToolCalls)
logger.Infof(ctx, "[Agent][Round-%d] Parallel execution of %d tool calls", round, n)
logger.Debugf(ctx, "%s Args: %s", toolTag, tc.Function.Arguments)
results := make([]types.ToolCall, n)
var mu sync.Mutex
g, gCtx := errgroup.WithContext(ctx)
toolCallStartTime := time.Now()
// Emit tool hint for UI progress display
toolHint := formatToolHint(tc.Function.Name, args)
e.eventBus.Emit(ctx, event.Event{
ID: tc.ID + "-tool-hint",
Type: event.EventAgentToolCall,
SessionID: sessionID,
Data: event.AgentToolCallData{
ToolCallID: tc.ID,
ToolName: tc.Function.Name,
Arguments: args,
Iteration: iteration,
Hint: toolHint,
},
for i, tc := range response.ToolCalls {
i, tc := i, tc // capture loop vars
g.Go(func() error {
toolCall := e.runToolCall(gCtx, tc, i, iteration, round, sessionID)
mu.Lock()
results[i] = toolCall
mu.Unlock()
return nil // best-effort: don't cancel siblings on failure
})
}
// Execute tool with timeout to prevent indefinite hangs
common.PipelineInfo(ctx, "Agent", "tool_call_start", map[string]interface{}{
"iteration": iteration,
"round": round,
"tool": tc.Function.Name,
"tool_call_id": tc.ID,
"tool_index": fmt.Sprintf("%d/%d", i+1, len(response.ToolCalls)),
})
toolCtx, toolCancel := context.WithTimeout(ctx, defaultToolExecTimeout)
result, err := e.toolRegistry.ExecuteTool(
toolCtx, tc.Function.Name,
json.RawMessage(tc.Function.Arguments),
)
toolCancel()
duration := time.Since(toolCallStartTime).Milliseconds()
_ = g.Wait()
toolCall := types.ToolCall{
ID: tc.ID,
Name: tc.Function.Name,
Args: args,
Result: result,
Duration: duration,
}
if err != nil {
logger.Errorf(ctx, "%s Failed in %dms: %v", toolTag, duration, err)
toolCall.Result = &types.ToolResult{
Success: false,
Error: err.Error(),
}
} else {
success := result != nil && result.Success
outputLen := 0
if result != nil {
outputLen = len(result.Output)
}
logger.Infof(ctx, "%s Completed in %dms: success=%v, output=%d chars",
toolTag, duration, success, outputLen)
}
// Pipeline event for monitoring
toolSuccess := toolCall.Result != nil && toolCall.Result.Success
pipelineFields := map[string]interface{}{
"iteration": iteration,
"round": round,
"tool": tc.Function.Name,
"tool_call_id": tc.ID,
"duration_ms": duration,
"success": toolSuccess,
}
if toolCall.Result != nil && toolCall.Result.Error != "" {
pipelineFields["error"] = toolCall.Result.Error
}
if err != nil {
common.PipelineError(ctx, "Agent", "tool_call_result", pipelineFields)
} else if toolSuccess {
common.PipelineInfo(ctx, "Agent", "tool_call_result", pipelineFields)
} else {
common.PipelineWarn(ctx, "Agent", "tool_call_result", pipelineFields)
}
// Debug-level output preview
if toolCall.Result != nil && toolCall.Result.Output != "" {
preview := toolCall.Result.Output
if len(preview) > 500 {
preview = preview[:500] + "... (truncated)"
}
logger.Debugf(ctx, "%s Output preview:\n%s", toolTag, preview)
}
if toolCall.Result != nil && toolCall.Result.Error != "" {
logger.Debugf(ctx, "%s Tool error: %s", toolTag, toolCall.Result.Error)
}
// Store tool call
// Append results and emit events in original order
for _, toolCall := range results {
step.ToolCalls = append(step.ToolCalls, toolCall)
// Emit tool result event (include structured data from tool result)
result := toolCall.Result
if result == nil {
result = &types.ToolResult{Success: false, Error: "no result"}
}
e.eventBus.Emit(ctx, event.Event{
ID: tc.ID + "-tool-result",
ID: toolCall.ID + "-tool-result",
Type: event.EventAgentToolResult,
SessionID: sessionID,
Data: event.AgentToolResultData{
ToolCallID: tc.ID,
ToolName: tc.Function.Name,
ToolCallID: toolCall.ID,
ToolName: toolCall.Name,
Output: result.Output,
Error: result.Error,
Success: result.Success,
Duration: duration,
Duration: toolCall.Duration,
Iteration: iteration,
Data: result.Data, // Pass structured data for frontend rendering
Data: result.Data,
},
})
// Emit tool execution event (for internal monitoring)
e.eventBus.Emit(ctx, event.Event{
ID: tc.ID + "-tool-exec",
ID: toolCall.ID + "-tool-exec",
Type: event.EventAgentTool,
SessionID: sessionID,
Data: event.AgentActionData{
Iteration: iteration,
ToolName: tc.Function.Name,
ToolInput: args,
ToolName: toolCall.Name,
ToolInput: toolCall.Args,
ToolOutput: result.Output,
Success: result.Success,
Error: result.Error,
Duration: duration,
Duration: toolCall.Duration,
},
})
}
}
// executeSingleToolCall runs one tool call sequentially (original behavior).
func (e *AgentEngine) executeSingleToolCall(
ctx context.Context, tc types.LLMToolCall, i int,
step *types.AgentStep, iteration, round int, sessionID string,
) {
toolCall := e.runToolCall(ctx, tc, i, iteration, round, sessionID)
step.ToolCalls = append(step.ToolCalls, toolCall)
result := toolCall.Result
if result == nil {
result = &types.ToolResult{Success: false, Error: "no result"}
}
e.eventBus.Emit(ctx, event.Event{
ID: toolCall.ID + "-tool-result",
Type: event.EventAgentToolResult,
SessionID: sessionID,
Data: event.AgentToolResultData{
ToolCallID: toolCall.ID,
ToolName: toolCall.Name,
Output: result.Output,
Error: result.Error,
Success: result.Success,
Duration: toolCall.Duration,
Iteration: iteration,
Data: result.Data,
},
})
e.eventBus.Emit(ctx, event.Event{
ID: toolCall.ID + "-tool-exec",
Type: event.EventAgentTool,
SessionID: sessionID,
Data: event.AgentActionData{
Iteration: iteration,
ToolName: toolCall.Name,
ToolInput: toolCall.Args,
ToolOutput: result.Output,
Success: result.Success,
Error: result.Error,
Duration: toolCall.Duration,
},
})
}
// runToolCall handles argument parsing, execution, logging, and pipeline events for a single tool call.
// It returns the completed ToolCall struct. Safe to call from multiple goroutines.
func (e *AgentEngine) runToolCall(
ctx context.Context, tc types.LLMToolCall, i int,
iteration, round int, sessionID string,
) types.ToolCall {
tc.ID = agenttools.NormalizeToolCallID(tc.ID, tc.Function.Name, i)
total := "?" // unknown in isolation; callers log the batch size
toolTag := fmt.Sprintf("[Agent][Round-%d][Tool %s (%d/%s)]",
round, tc.Function.Name, i+1, total)
var args map[string]any
argsStr := tc.Function.Arguments
if err := json.Unmarshal([]byte(argsStr), &args); err != nil {
repaired := agenttools.RepairJSON(argsStr)
if repairErr := json.Unmarshal([]byte(repaired), &args); repairErr != nil {
logger.Errorf(ctx, "%s Failed to parse arguments (repair failed): %v", toolTag, err)
return types.ToolCall{
ID: tc.ID,
Name: tc.Function.Name,
Args: map[string]any{"_raw": argsStr},
Result: &types.ToolResult{
Success: false,
Error: fmt.Sprintf(
"Failed to parse tool arguments: %v", err,
) + "\n\n[Analyze the error above and try a different approach.]",
},
}
}
logger.Warnf(ctx, "%s Repaired malformed JSON arguments", toolTag)
tc.Function.Arguments = repaired
}
logger.Debugf(ctx, "%s Args: %s", toolTag, tc.Function.Arguments)
toolCallStartTime := time.Now()
// Emit tool hint for UI progress display
toolHint := formatToolHint(tc.Function.Name, args)
e.eventBus.Emit(ctx, event.Event{
ID: tc.ID + "-tool-hint",
Type: event.EventAgentToolCall,
SessionID: sessionID,
Data: event.AgentToolCallData{
ToolCallID: tc.ID,
ToolName: tc.Function.Name,
Arguments: args,
Iteration: iteration,
Hint: toolHint,
},
})
common.PipelineInfo(ctx, "Agent", "tool_call_start", map[string]interface{}{
"iteration": iteration,
"round": round,
"tool": tc.Function.Name,
"tool_call_id": tc.ID,
"tool_index": fmt.Sprintf("%d/%s", i+1, total),
})
toolCtx, toolCancel := context.WithTimeout(ctx, defaultToolExecTimeout)
result, err := e.toolRegistry.ExecuteTool(
toolCtx, tc.Function.Name,
json.RawMessage(tc.Function.Arguments),
)
toolCancel()
duration := time.Since(toolCallStartTime).Milliseconds()
toolCall := types.ToolCall{
ID: tc.ID,
Name: tc.Function.Name,
Args: args,
Result: result,
Duration: duration,
}
if err != nil {
logger.Errorf(ctx, "%s Failed in %dms: %v", toolTag, duration, err)
toolCall.Result = &types.ToolResult{
Success: false,
Error: err.Error(),
}
} else {
success := result != nil && result.Success
outputLen := 0
if result != nil {
outputLen = len(result.Output)
}
logger.Infof(ctx, "%s Completed in %dms: success=%v, output=%d chars",
toolTag, duration, success, outputLen)
}
// Pipeline event for monitoring
toolSuccess := toolCall.Result != nil && toolCall.Result.Success
pipelineFields := map[string]interface{}{
"iteration": iteration,
"round": round,
"tool": tc.Function.Name,
"tool_call_id": tc.ID,
"duration_ms": duration,
"success": toolSuccess,
}
if toolCall.Result != nil && toolCall.Result.Error != "" {
pipelineFields["error"] = toolCall.Result.Error
}
if err != nil {
common.PipelineError(ctx, "Agent", "tool_call_result", pipelineFields)
} else if toolSuccess {
common.PipelineInfo(ctx, "Agent", "tool_call_result", pipelineFields)
} else {
common.PipelineWarn(ctx, "Agent", "tool_call_result", pipelineFields)
}
if toolCall.Result != nil && toolCall.Result.Output != "" {
preview := toolCall.Result.Output
if len(preview) > 500 {
preview = preview[:500] + "... (truncated)"
}
logger.Debugf(ctx, "%s Output preview:\n%s", toolTag, preview)
}
if toolCall.Result != nil && toolCall.Result.Error != "" {
logger.Debugf(ctx, "%s Tool error: %s", toolTag, toolCall.Result.Error)
}
return toolCall
}
+19
View File
@@ -19,6 +19,16 @@ const (
PlatformMattermost Platform = "mattermost"
)
// SessionMode determines how IM sessions are resolved.
type SessionMode string
const (
// SessionModeUser resolves sessions by (platform, user_id, chat_id, tenant_id).
SessionModeUser SessionMode = "user"
// SessionModeThread resolves sessions by (platform, thread_id, chat_id, tenant_id).
SessionModeThread SessionMode = "thread"
)
// MessageType identifies the kind of IM message.
type MessageType string
@@ -52,6 +62,15 @@ type IncomingMessage struct {
FileName string
// FileSize is the file size in bytes (for file messages, optional).
FileSize int64
// ThreadID is the platform-specific thread identifier.
// - Slack: thread_ts (top-level message uses its own timestamp)
// - Mattermost: root_id, or post_id if top-level
// - Feishu: root_id, or message_id if top-level
// - Telegram: message_thread_id (Forum Topics only)
// Empty for platforms without thread support (WeCom, DingTalk).
// In thread mode, top-level messages use their own ID as ThreadID,
// effectively creating a new session per top-level message.
ThreadID string
// Extra holds platform-specific fields (e.g., WeCom stream ID).
Extra map[string]string
}
+12
View File
@@ -205,6 +205,8 @@ type feishuEvent struct {
type feishuMessage struct {
MessageID string `json:"message_id"`
RootID string `json:"root_id"`
ParentID string `json:"parent_id"`
MessageType string `json:"message_type"`
ChatType string `json:"chat_type"`
ChatID string `json:"chat_id"`
@@ -263,6 +265,12 @@ func (a *Adapter) ParseCallback(c *gin.Context) (*im.IncomingMessage, error) {
}
msg := eventBody.Event.Message
// Compute thread ID: use root_id for threaded replies, or message_id for top-level messages.
threadID := msg.RootID
if threadID == "" {
threadID = msg.MessageID
}
// Determine chat type
chatType := im.ChatTypeDirect
chatID := ""
@@ -308,6 +316,7 @@ func (a *Adapter) ParseCallback(c *gin.Context) (*im.IncomingMessage, error) {
ChatType: chatType,
Content: strings.TrimSpace(content),
MessageID: msg.MessageID,
ThreadID: threadID,
}, nil
case "file":
@@ -328,6 +337,7 @@ func (a *Adapter) ParseCallback(c *gin.Context) (*im.IncomingMessage, error) {
ChatID: chatID,
ChatType: chatType,
MessageID: msg.MessageID,
ThreadID: threadID,
FileKey: fileContent.FileKey,
FileName: fileContent.FileName,
}, nil
@@ -349,6 +359,7 @@ func (a *Adapter) ParseCallback(c *gin.Context) (*im.IncomingMessage, error) {
ChatID: chatID,
ChatType: chatType,
MessageID: msg.MessageID,
ThreadID: threadID,
FileKey: imageContent.ImageKey,
FileName: imageContent.ImageKey + ".png",
}, nil
@@ -411,6 +422,7 @@ func (a *Adapter) ParseCallback(c *gin.Context) (*im.IncomingMessage, error) {
ChatType: chatType,
Content: content,
MessageID: msg.MessageID,
ThreadID: threadID,
}, nil
default:
+53
View File
@@ -0,0 +1,53 @@
package feishu
import "testing"
func TestFeishuThreadID_ThreadedReply(t *testing.T) {
// Simulate: message is a reply in a thread (root_id is set)
msg := &feishuMessage{
MessageID: "msg-reply-1",
RootID: "msg-root-1",
ParentID: "msg-parent-1",
}
threadID := msg.RootID
if threadID == "" {
threadID = msg.MessageID
}
if threadID != "msg-root-1" {
t.Errorf("threadID = %q, want %q", threadID, "msg-root-1")
}
}
func TestFeishuThreadID_TopLevelMessage(t *testing.T) {
// Simulate: top-level message (root_id is empty)
msg := &feishuMessage{
MessageID: "msg-top-1",
RootID: "",
ParentID: "",
}
threadID := msg.RootID
if threadID == "" {
threadID = msg.MessageID
}
if threadID != "msg-top-1" {
t.Errorf("threadID = %q, want %q (should use MessageID as fallback)", threadID, "msg-top-1")
}
}
func TestFeishuMessageStruct_JSONFields(t *testing.T) {
// Verify the struct fields exist and have correct zero values
msg := feishuMessage{}
if msg.RootID != "" {
t.Errorf("RootID zero value = %q, want empty", msg.RootID)
}
if msg.ParentID != "" {
t.Errorf("ParentID zero value = %q, want empty", msg.ParentID)
}
if msg.MessageID != "" {
t.Errorf("MessageID zero value = %q, want empty", msg.MessageID)
}
}
+9 -1
View File
@@ -114,7 +114,14 @@ func (a *Adapter) ParseCallback(c *gin.Context) (*im.IncomingMessage, error) {
} else {
threadRoot = payload.RootID
if threadRoot == "" {
threadRoot = payload.PostID
// Outgoing webhooks may omit root_id for thread replies.
// Fetch the post to resolve the actual thread root.
if actualRootID, err := a.client.GetPost(c.Request.Context(), payload.PostID); err == nil && actualRootID != "" {
threadRoot = actualRootID
} else {
// Top-level message: use its own PostID as thread root.
threadRoot = payload.PostID
}
}
}
@@ -126,6 +133,7 @@ func (a *Adapter) ParseCallback(c *gin.Context) (*im.IncomingMessage, error) {
ChatType: im.ChatTypeGroup,
Content: strings.TrimSpace(payload.Text),
MessageID: payload.PostID,
ThreadID: threadRoot,
Extra: map[string]string{
extraKeyThreadRoot: threadRoot,
extraKeyChannelID: payload.ChannelID,
+153
View File
@@ -0,0 +1,153 @@
package mattermost
import (
"encoding/json"
"testing"
)
func TestParseOutgoingBody_ThreadRoot(t *testing.T) {
tests := []struct {
name string
payload outgoingPayload
postReplyToMain bool
wantThreadRoot string
}{
{
name: "threaded reply has RootID",
payload: outgoingPayload{
PostID: "post-123",
RootID: "root-456",
},
postReplyToMain: false,
wantThreadRoot: "root-456",
},
{
name: "top-level message uses PostID as thread root",
payload: outgoingPayload{
PostID: "post-789",
RootID: "",
},
postReplyToMain: false,
wantThreadRoot: "post-789",
},
{
name: "postReplyToMain clears thread root",
payload: outgoingPayload{
PostID: "post-123",
RootID: "root-456",
},
postReplyToMain: true,
wantThreadRoot: "",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var threadRoot string
if tt.postReplyToMain {
threadRoot = ""
} else {
threadRoot = tt.payload.RootID
if threadRoot == "" {
threadRoot = tt.payload.PostID
}
}
if threadRoot != tt.wantThreadRoot {
t.Errorf("threadRoot = %q, want %q", threadRoot, tt.wantThreadRoot)
}
})
}
}
func TestParseOutgoingBody_JSON(t *testing.T) {
body := `{"token":"tok","user_id":"u1","user_name":"alice","channel_id":"ch1","post_id":"p1","text":"hello","root_id":"r1"}`
payload, err := parseOutgoingBody("application/json", []byte(body))
if err != nil {
t.Fatalf("parseOutgoingBody error: %v", err)
}
if payload.RootID != "r1" {
t.Errorf("RootID = %q, want %q", payload.RootID, "r1")
}
if payload.PostID != "p1" {
t.Errorf("PostID = %q, want %q", payload.PostID, "p1")
}
}
func TestParseOutgoingBody_FormEncoded(t *testing.T) {
body := "token=tok&user_id=u1&channel_id=ch1&post_id=p2&text=hello&root_id=r2"
payload, err := parseOutgoingBody("application/x-www-form-urlencoded", []byte(body))
if err != nil {
t.Fatalf("parseOutgoingBody error: %v", err)
}
if payload.RootID != "r2" {
t.Errorf("RootID = %q, want %q", payload.RootID, "r2")
}
if payload.PostID != "p2" {
t.Errorf("PostID = %q, want %q", payload.PostID, "p2")
}
}
func TestThreadIDInMessage(t *testing.T) {
// Simulate the adapter logic: build the message and verify ThreadID
payload := outgoingPayload{
Token: "tok",
UserID: "user-1",
UserName: "alice",
ChannelID: "ch-1",
PostID: "post-100",
Text: "hello",
RootID: "root-200",
}
threadRoot := payload.RootID
if threadRoot == "" {
threadRoot = payload.PostID
}
// Verify the Extra map and ThreadID would be consistent
extra := map[string]string{
extraKeyThreadRoot: threadRoot,
extraKeyChannelID: payload.ChannelID,
}
if extra[extraKeyThreadRoot] != "root-200" {
t.Errorf("Extra thread_root_id = %q, want %q", extra[extraKeyThreadRoot], "root-200")
}
// ThreadID should equal threadRoot
threadID := threadRoot
if threadID != "root-200" {
t.Errorf("ThreadID = %q, want %q", threadID, "root-200")
}
}
func TestParseFileIDs(t *testing.T) {
tests := []struct {
name string
raw json.RawMessage
want []string
}{
{"array", json.RawMessage(`["f1","f2"]`), []string{"f1", "f2"}},
{"string", json.RawMessage(`"f3"`), []string{"f3"}},
{"empty", nil, nil},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := parseFileIDs(tt.raw)
if len(got) != len(tt.want) {
t.Fatalf("parseFileIDs() len = %d, want %d", len(got), len(tt.want))
}
for i := range got {
if got[i] != tt.want[i] {
t.Errorf("parseFileIDs()[%d] = %q, want %q", i, got[i], tt.want[i])
}
}
})
}
}
+31
View File
@@ -88,6 +88,37 @@ func (c *Client) CreatePost(ctx context.Context, channelID, rootID, message stri
return created.ID, nil
}
// GetPost fetches a post by ID, returning its root_id (empty if top-level).
func (c *Client) GetPost(ctx context.Context, postID string) (rootID string, err error) {
url := fmt.Sprintf("%s/posts/%s", c.baseURL, postID)
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
if err != nil {
return "", err
}
c.authHeader(req)
req.Header.Del("Content-Type")
resp, err := c.httpClient.Do(req)
if err != nil {
return "", err
}
defer resp.Body.Close()
respBody, _ := io.ReadAll(resp.Body)
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
return "", fmt.Errorf("mattermost get post: status=%d body=%s", resp.StatusCode, truncateForErr(respBody))
}
var post struct {
ID string `json:"id"`
RootID string `json:"root_id"`
}
if err := json.Unmarshal(respBody, &post); err != nil {
return "", fmt.Errorf("decode get post: %w", err)
}
return post.RootID, nil
}
// PatchPostMessage updates a post's message field.
func (c *Client) PatchPostMessage(ctx context.Context, postID, message string) error {
payload, err := json.Marshal(map[string]string{"message": message})
+115 -13
View File
@@ -151,7 +151,12 @@ type Service struct {
// makeUserKey builds the canonical key used to identify a user's request
// across the queue, inflight map, and /stop command.
func makeUserKey(channelID, userID, chatID string) string {
// threadID should only be non-empty when channel.SessionMode == "thread";
// callers must guard this to avoid leaking thread scope into user-mode keys.
func makeUserKey(channelID, userID, chatID, threadID string) string {
if threadID != "" {
return fmt.Sprintf("%s:%s:%s:%s", channelID, userID, chatID, threadID)
}
return fmt.Sprintf("%s:%s:%s", channelID, userID, chatID)
}
@@ -716,6 +721,7 @@ func (s *Service) HandleMessage(ctx context.Context, msg *IncomingMessage, chann
attribute.String("im.platform", string(msg.Platform)),
attribute.String("im.user_id", msg.UserID),
attribute.String("im.chat_id", msg.ChatID),
attribute.String("im.thread_id", msg.ThreadID),
attribute.String("im.message_type", string(msg.MessageType)),
)
@@ -752,12 +758,21 @@ func (s *Service) HandleMessage(ctx context.Context, msg *IncomingMessage, chann
}
}
span.SetAttributes(attribute.String("im.session_mode", channel.SessionMode))
// Resolve threadID for key building — only include in thread mode to avoid
// leaking thread scope into user-mode rate limit / inflight keys.
threadID := ""
if channel.SessionMode == string(SessionModeThread) {
threadID = msg.ThreadID
}
// Rate limit: enforce per-user sliding window to prevent abuse.
// Slash-commands (/stop, /clear, etc.) bypass rate limiting so the user
// always retains control over the bot even under heavy messaging.
isCommand := s.cmdRegistry.IsRegistered(msg.Content)
if !isCommand {
rateLimitKey := makeUserKey(channelID, msg.UserID, msg.ChatID)
rateLimitKey := makeUserKey(channelID, msg.UserID, msg.ChatID, threadID)
if !s.rateLimiter.Allow(rateLimitKey) {
logger.Warnf(ctx, "[IM] Rate limited: channel=%s user=%s chat=%s", channelID, msg.UserID, msg.ChatID)
_ = adapter.SendReply(ctx, msg, &ReplyMessage{
@@ -792,7 +807,7 @@ func (s *Service) HandleMessage(ctx context.Context, msg *IncomingMessage, chann
sessionCtx = context.WithValue(sessionCtx, types.TenantInfoContextKey, tenant)
// 2. Resolve or create a WeKnora session
channelSession, err := s.resolveSession(sessionCtx, msg, tenantID, agentID, channelID)
channelSession, err := s.resolveSession(sessionCtx, msg, tenantID, agentID, channelID, channel.SessionMode)
if err != nil {
return fmt.Errorf("resolve session: %w", err)
}
@@ -831,7 +846,7 @@ func (s *Service) HandleMessage(ctx context.Context, msg *IncomingMessage, chann
// 5. Enqueue the QA request into the bounded worker pool.
// The worker pool controls LLM concurrency and provides backpressure.
qaCtx, qaCancel := context.WithCancel(sessionCtx)
userKey := makeUserKey(channelID, msg.UserID, msg.ChatID)
userKey := makeUserKey(channelID, msg.UserID, msg.ChatID, threadID)
req := &qaRequest{
ctx: qaCtx,
@@ -1000,7 +1015,11 @@ func (s *Service) handleCommand(
logger.Warnf(ctx, "[IM] Failed to clear session context: %v", err)
}
case ActionStop:
inflightKey := makeUserKey(channel.ID, msg.UserID, msg.ChatID)
stopThreadID := ""
if channel.SessionMode == string(SessionModeThread) {
stopThreadID = msg.ThreadID
}
inflightKey := makeUserKey(channel.ID, msg.UserID, msg.ChatID, stopThreadID)
// 1. Try local cancel: remove from queue or cancel in-flight.
var localSessionID, localMessageID string
@@ -1080,9 +1099,20 @@ func (s *Service) sendStreamReply(ctx context.Context, msg *IncomingMessage, str
return nil
}
// resolveSession finds or creates a ChannelSession for the given IM message.
// ctx must already carry TenantIDContextKey and TenantInfoContextKey.
func (s *Service) resolveSession(ctx context.Context, msg *IncomingMessage, tenantID uint64, agentID string, imChannelID string) (*ChannelSession, error) {
// resolveSession dispatches to the appropriate session resolution strategy
// based on the channel's session mode.
func (s *Service) resolveSession(ctx context.Context, msg *IncomingMessage, tenantID uint64, agentID string, imChannelID string, sessionMode string) (*ChannelSession, error) {
switch SessionMode(sessionMode) {
case SessionModeThread:
return s.resolveThreadSession(ctx, msg, tenantID, agentID, imChannelID)
default: // SessionModeUser
return s.resolveUserSession(ctx, msg, tenantID, agentID, imChannelID)
}
}
// resolveUserSession finds or creates a ChannelSession keyed by (platform, user_id, chat_id, tenant_id).
// This is the original session resolution strategy.
func (s *Service) resolveUserSession(ctx context.Context, msg *IncomingMessage, tenantID uint64, agentID string, imChannelID string) (*ChannelSession, error) {
var cs ChannelSession
result := s.db.Where("platform = ? AND user_id = ? AND chat_id = ? AND tenant_id = ? AND deleted_at IS NULL",
string(msg.Platform), msg.UserID, msg.ChatID, tenantID).
@@ -1125,14 +1155,9 @@ func (s *Service) resolveSession(ctx context.Context, msg *IncomingMessage, tena
IMChannelID: imChannelID,
}
if err := s.db.Create(&cs).Error; err != nil {
// The insert failed (likely unique constraint from a concurrent request on
// another instance). Clean up the orphaned Session we just created — it has
// no messages yet, so a direct delete is safe.
if delErr := s.db.Where("id = ?", createdSession.ID).Delete(createdSession).Error; delErr != nil {
logger.Warnf(ctx, "[IM] Failed to clean up orphaned session %s: %v", createdSession.ID, delErr)
}
// Fetch the existing ChannelSession created by the winning instance.
var existing ChannelSession
if findErr := s.db.Where("platform = ? AND user_id = ? AND chat_id = ? AND tenant_id = ? AND deleted_at IS NULL",
string(msg.Platform), msg.UserID, msg.ChatID, tenantID).
@@ -1148,6 +1173,83 @@ func (s *Service) resolveSession(ctx context.Context, msg *IncomingMessage, tena
return &cs, nil
}
// resolveThreadSession finds or creates a ChannelSession keyed by (platform, chat_id, thread_id, tenant_id).
// In thread mode, each message thread gets its own session. Multiple users in the
// same thread share the same session. Top-level messages use their own ID as
// ThreadID, creating a new session per top-level message.
func (s *Service) resolveThreadSession(ctx context.Context, msg *IncomingMessage, tenantID uint64, agentID string, imChannelID string) (*ChannelSession, error) {
threadID := msg.ThreadID
if threadID == "" {
// Defense-in-depth: frontend blocks thread mode for unsupported platforms,
// but if ThreadID is somehow empty, fall back to user-mode resolution
// to avoid creating a shared session for all empty-thread messages.
logger.Warnf(ctx, "[IM] Thread mode but ThreadID is empty (platform=%s chat=%s), falling back to user session", msg.Platform, msg.ChatID)
return s.resolveUserSession(ctx, msg, tenantID, agentID, imChannelID)
}
var cs ChannelSession
result := s.db.Where(
"platform = ? AND chat_id = ? AND thread_id = ? AND tenant_id = ? AND deleted_at IS NULL",
string(msg.Platform), threadID, msg.ChatID, tenantID,
).First(&cs)
if result.Error == nil {
return &cs, nil
}
if result.Error != gorm.ErrRecordNotFound {
return nil, fmt.Errorf("query thread session: %w", result.Error)
}
// Build a session title with thread ID suffix for traceability.
threadSuffix := threadID
if len(threadSuffix) > 8 {
threadSuffix = threadSuffix[len(threadSuffix)-8:]
}
title := fmt.Sprintf("IM-%s-thread-%s", msg.Platform, threadSuffix)
newSession := &types.Session{
TenantID: tenantID,
Title: title,
Description: fmt.Sprintf("Thread-based session from %s IM", msg.Platform),
}
createdSession, err := s.sessionService.CreateSession(ctx, newSession)
if err != nil {
return nil, fmt.Errorf("create session: %w", err)
}
cs = ChannelSession{
Platform: string(msg.Platform),
UserID: msg.UserID, // record the first creator
ChatID: msg.ChatID,
ThreadID: threadID,
SessionID: createdSession.ID,
TenantID: tenantID,
AgentID: agentID,
IMChannelID: imChannelID,
}
if err := s.db.Create(&cs).Error; err != nil {
// Unique constraint fallback for concurrent creation.
if delErr := s.db.Where("id = ?", createdSession.ID).Delete(createdSession).Error; delErr != nil {
logger.Warnf(ctx, "[IM] Failed to clean up orphaned session %s: %v", createdSession.ID, delErr)
}
var existing ChannelSession
if findErr := s.db.Where(
"platform = ? AND chat_id = ? AND thread_id = ? AND tenant_id = ? AND deleted_at IS NULL",
string(msg.Platform), msg.ChatID, threadID, tenantID,
).First(&existing).Error; findErr != nil {
return nil, fmt.Errorf("create thread session: %w (lookup fallback: %v)", err, findErr)
}
return &existing, nil
}
logger.Infof(ctx, "[IM] Created new thread session: platform=%s thread=%s chat=%s -> session=%s",
msg.Platform, threadID, msg.ChatID, createdSession.ID)
return &cs, nil
}
// ── Agent tool call progress formatting ──────────────────────────────
// These helpers format tool-call / tool-result events as Markdown text
// that is injected into the streaming reply so IM users can see the
+145
View File
@@ -0,0 +1,145 @@
package im
import "testing"
func TestMakeUserKey_UserMode(t *testing.T) {
tests := []struct {
name string
channelID string
userID string
chatID string
threadID string
want string
}{
{
name: "user mode with empty threadID",
channelID: "ch-1",
userID: "user-1",
chatID: "chat-1",
threadID: "",
want: "ch-1:user-1:chat-1",
},
{
name: "user mode with empty chatID (DM)",
channelID: "ch-1",
userID: "user-1",
chatID: "",
threadID: "",
want: "ch-1:user-1:",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := makeUserKey(tt.channelID, tt.userID, tt.chatID, tt.threadID)
if got != tt.want {
t.Errorf("makeUserKey() = %q, want %q", got, tt.want)
}
})
}
}
func TestMakeUserKey_ThreadMode(t *testing.T) {
tests := []struct {
name string
channelID string
userID string
chatID string
threadID string
want string
}{
{
name: "thread mode with Slack thread_ts",
channelID: "ch-1",
userID: "user-1",
chatID: "chat-1",
threadID: "1234567890.123456",
want: "ch-1:user-1:chat-1:1234567890.123456",
},
{
name: "thread mode with Mattermost root_id",
channelID: "ch-2",
userID: "user-2",
chatID: "chat-2",
threadID: "abc123def456",
want: "ch-2:user-2:chat-2:abc123def456",
},
{
name: "thread mode with Telegram topic ID",
channelID: "ch-3",
userID: "user-3",
chatID: "chat-3",
threadID: "42",
want: "ch-3:user-3:chat-3:42",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := makeUserKey(tt.channelID, tt.userID, tt.chatID, tt.threadID)
if got != tt.want {
t.Errorf("makeUserKey() = %q, want %q", got, tt.want)
}
})
}
}
func TestMakeUserKey_ThreadIDGuard(t *testing.T) {
// Verify that the same user+chat produces different keys with different threadIDs
keyA := makeUserKey("ch", "user", "chat", "thread-A")
keyB := makeUserKey("ch", "user", "chat", "thread-B")
keyNone := makeUserKey("ch", "user", "chat", "")
if keyA == keyB {
t.Error("different threadIDs should produce different keys")
}
if keyA == keyNone {
t.Error("thread key should differ from non-thread key")
}
if keyB == keyNone {
t.Error("thread key should differ from non-thread key")
}
}
func TestMakeUserKey_SameThreadDifferentUsers(t *testing.T) {
// In thread mode, different users in the same thread produce different keys
// (this is intentional: /stop only cancels the caller's own request)
keyUserA := makeUserKey("ch", "alice", "chat", "thread-1")
keyUserB := makeUserKey("ch", "bob", "chat", "thread-1")
if keyUserA == keyUserB {
t.Error("different users in same thread should have different keys")
}
}
func TestIncomingMessageThreadID(t *testing.T) {
// Verify ThreadID field works correctly on IncomingMessage
msg := &IncomingMessage{
Platform: PlatformSlack,
UserID: "U123",
ChatID: "C456",
MessageID: "1234567890.123456",
ThreadID: "1234567890.123456",
}
if msg.ThreadID != msg.MessageID {
t.Errorf("Slack ThreadID should equal MessageID for top-level, got ThreadID=%q MessageID=%q",
msg.ThreadID, msg.MessageID)
}
// Mattermost: ThreadID from Extra
msgMM := &IncomingMessage{
Platform: PlatformMattermost,
UserID: "user-1",
ChatID: "channel-1",
MessageID: "post-123",
ThreadID: "root-456",
Extra: map[string]string{
"thread_root_id": "root-456",
},
}
if msgMM.ThreadID != msgMM.Extra["thread_root_id"] {
t.Error("Mattermost ThreadID should match Extra thread_root_id")
}
}
+1
View File
@@ -70,6 +70,7 @@ func parseIncomingMessage(user, channel, text, ts string, chatType im.ChatType,
ChatType: chatType,
Content: strings.TrimSpace(content),
MessageID: ts,
ThreadID: ts,
}
if len(files) > 0 {
+70
View File
@@ -0,0 +1,70 @@
package slack
import (
"testing"
"github.com/Tencent/WeKnora/internal/im"
slacklib "github.com/slack-go/slack"
)
func TestParseIncomingMessage_ThreadID(t *testing.T) {
tests := []struct {
name string
ts string
wantThreadID string
wantMessageID string
}{
{
name: "top-level message uses own timestamp",
ts: "1234567890.123456",
wantThreadID: "1234567890.123456",
wantMessageID: "1234567890.123456",
},
{
name: "threaded reply uses thread_ts",
ts: "1234567890.000001",
wantThreadID: "1234567890.000001",
wantMessageID: "1234567890.000001",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
msg := parseIncomingMessage("U123", "C456", "hello", tt.ts, im.ChatTypeGroup, nil)
if msg.ThreadID != tt.wantThreadID {
t.Errorf("ThreadID = %q, want %q", msg.ThreadID, tt.wantThreadID)
}
if msg.MessageID != tt.wantMessageID {
t.Errorf("MessageID = %q, want %q", msg.MessageID, tt.wantMessageID)
}
})
}
}
func TestParseIncomingMessage_ThreadID_WithFiles(t *testing.T) {
files := []slacklib.File{
{ID: "F123", Name: "test.pdf", Size: 1024, Mimetype: "application/pdf"},
}
msg := parseIncomingMessage("U123", "C456", "", "1234567890.999", im.ChatTypeDirect, files)
if msg.ThreadID != "1234567890.999" {
t.Errorf("ThreadID = %q, want %q", msg.ThreadID, "1234567890.999")
}
if msg.MessageType != im.MessageTypeFile {
t.Errorf("MessageType = %q, want %q", msg.MessageType, im.MessageTypeFile)
}
}
func TestParseIncomingMessage_MentionStripping(t *testing.T) {
// Ensure mention stripping doesn't affect ThreadID
msg := parseIncomingMessage("U123", "C456", "<@U999> hello world", "ts-123", im.ChatTypeGroup, nil)
if msg.ThreadID != "ts-123" {
t.Errorf("ThreadID = %q, want %q", msg.ThreadID, "ts-123")
}
if msg.Content != "hello world" {
t.Errorf("Content = %q, want %q", msg.Content, "hello world")
}
}
+33 -7
View File
@@ -8,6 +8,7 @@ import (
"fmt"
"io"
"net/http"
"strconv"
"strings"
"sync"
"time"
@@ -76,12 +77,13 @@ type telegramUpdate struct {
}
type telegramMsg struct {
MessageID int `json:"message_id"`
From *telegramUser `json:"from"`
Chat telegramChat `json:"chat"`
Text string `json:"text"`
Document *telegramDoc `json:"document"`
Photo []telegramPhoto `json:"photo"`
MessageID int `json:"message_id"`
MessageThreadID int `json:"message_thread_id"`
From *telegramUser `json:"from"`
Chat telegramChat `json:"chat"`
Text string `json:"text"`
Document *telegramDoc `json:"document"`
Photo []telegramPhoto `json:"photo"`
}
type telegramUser struct {
@@ -154,6 +156,11 @@ func parseTelegramMessage(msg *telegramMsg) *im.IncomingMessage {
}
}
threadID := ""
if msg.MessageThreadID != 0 {
threadID = fmt.Sprintf("%d", msg.MessageThreadID)
}
incoming := &im.IncomingMessage{
Platform: im.PlatformTelegram,
UserID: userID,
@@ -161,6 +168,7 @@ func parseTelegramMessage(msg *telegramMsg) *im.IncomingMessage {
ChatID: chatID,
ChatType: chatType,
MessageID: fmt.Sprintf("%d", msg.MessageID),
ThreadID: threadID,
MessageType: im.MessageTypeText,
Content: msg.Text,
}
@@ -206,7 +214,20 @@ func resolveChatID(incoming *im.IncomingMessage) string {
// ── Send reply ──
func (a *Adapter) SendReply(ctx context.Context, incoming *im.IncomingMessage, reply *im.ReplyMessage) error {
return a.sendMessage(ctx, resolveChatID(incoming), transformThinkBlocks(reply.Content), "")
chatID := resolveChatID(incoming)
text := transformThinkBlocks(reply.Content)
body := map[string]interface{}{
"chat_id": chatID,
"text": text,
"parse_mode": "Markdown",
}
if incoming.ThreadID != "" {
if tid, err := strconv.Atoi(incoming.ThreadID); err == nil {
body["message_thread_id"] = tid
}
}
return a.callAPI(ctx, "sendMessage", body)
}
func (a *Adapter) sendMessage(ctx context.Context, chatID, text, replyToMessageID string) error {
@@ -343,6 +364,11 @@ func (a *Adapter) StartStream(ctx context.Context, incoming *im.IncomingMessage)
"chat_id": chatID,
"text": "正在思考...",
}
if incoming.ThreadID != "" {
if tid, err := strconv.Atoi(incoming.ThreadID); err == nil {
body["message_thread_id"] = tid
}
}
var sentMsg struct {
MessageID int `json:"message_id"`
}
+108
View File
@@ -0,0 +1,108 @@
package telegram
import (
"testing"
"github.com/Tencent/WeKnora/internal/im"
)
func TestParseTelegramMessage_ForumTopicThread(t *testing.T) {
msg := &telegramMsg{
MessageID: 100,
MessageThreadID: 42, // Forum topic ID
From: &telegramUser{ID: 1001, FirstName: "Alice"},
Chat: telegramChat{ID: -9999, Type: "supergroup"},
Text: "hello",
}
incoming := parseTelegramMessage(msg)
if incoming == nil {
t.Fatal("expected non-nil message")
}
if incoming.ThreadID != "42" {
t.Errorf("ThreadID = %q, want %q", incoming.ThreadID, "42")
}
}
func TestParseTelegramMessage_NonForumGroup(t *testing.T) {
msg := &telegramMsg{
MessageID: 200,
MessageThreadID: 0, // not a Forum group
From: &telegramUser{ID: 1002, FirstName: "Bob"},
Chat: telegramChat{ID: -8888, Type: "group"},
Text: "hello",
}
incoming := parseTelegramMessage(msg)
if incoming == nil {
t.Fatal("expected non-nil message")
}
// Non-Forum groups: ThreadID should be empty
if incoming.ThreadID != "" {
t.Errorf("ThreadID = %q, want empty for non-Forum group", incoming.ThreadID)
}
}
func TestParseTelegramMessage_DirectMessage(t *testing.T) {
msg := &telegramMsg{
MessageID: 300,
From: &telegramUser{ID: 1003, FirstName: "Carol"},
Chat: telegramChat{ID: 1003, Type: "private"},
Text: "hi bot",
}
incoming := parseTelegramMessage(msg)
if incoming == nil {
t.Fatal("expected non-nil message")
}
if incoming.ThreadID != "" {
t.Errorf("ThreadID = %q, want empty for DM", incoming.ThreadID)
}
if incoming.ChatType != im.ChatTypeDirect {
t.Errorf("ChatType = %q, want %q", incoming.ChatType, im.ChatTypeDirect)
}
}
func TestParseTelegramMessage_NilMessage(t *testing.T) {
incoming := parseTelegramMessage(nil)
if incoming != nil {
t.Error("expected nil for nil message")
}
}
func TestParseTelegramMessage_Document(t *testing.T) {
msg := &telegramMsg{
MessageID: 400,
MessageThreadID: 7, // in a Forum topic
From: &telegramUser{ID: 1004, FirstName: "Dave"},
Chat: telegramChat{ID: -7777, Type: "supergroup"},
Document: &telegramDoc{
FileID: "doc-123",
FileName: "report.pdf",
FileSize: 2048,
},
}
incoming := parseTelegramMessage(msg)
if incoming == nil {
t.Fatal("expected non-nil message")
}
if incoming.ThreadID != "7" {
t.Errorf("ThreadID = %q, want %q", incoming.ThreadID, "7")
}
if incoming.MessageType != im.MessageTypeFile {
t.Errorf("MessageType = %q, want %q", incoming.MessageType, im.MessageTypeFile)
}
}
func TestParseUpdate_NilMessage(t *testing.T) {
update := &telegramUpdate{UpdateID: 1, Message: nil}
incoming := parseUpdate(update)
if incoming != nil {
t.Error("expected nil for nil update.Message")
}
}
+26 -1
View File
@@ -24,6 +24,7 @@ type IMChannel struct {
OutputMode string `json:"output_mode" gorm:"type:varchar(20);not null;default:'stream'"`
KnowledgeBaseID string `json:"knowledge_base_id" gorm:"type:varchar(36);default:''"`
BotIdentity string `json:"bot_identity" gorm:"type:varchar(255);not null;default:'';uniqueIndex:idx_im_channels_bot_identity,where:deleted_at IS NULL AND bot_identity != ''"`
SessionMode string `json:"session_mode" gorm:"type:varchar(20);not null;default:'user'"`
Credentials types.JSON `json:"credentials" gorm:"type:jsonb;not null;default:'{}'"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
@@ -48,16 +49,39 @@ func (ch *IMChannel) BeforeCreate(tx *gorm.DB) error {
if ch.OutputMode == "" {
ch.OutputMode = "stream"
}
if ch.SessionMode == "" {
ch.SessionMode = string(SessionModeUser)
}
if err := ch.validateSessionMode(); err != nil {
return err
}
ch.BotIdentity = ch.computeBotIdentity()
return nil
}
// BeforeSave ensures bot_identity is recomputed on every save (create + update).
// BeforeSave ensures bot_identity is recomputed and session_mode is validated
// on every save (create + update).
func (ch *IMChannel) BeforeSave(tx *gorm.DB) error {
if ch.SessionMode == "" {
ch.SessionMode = string(SessionModeUser)
}
if err := ch.validateSessionMode(); err != nil {
return err
}
ch.BotIdentity = ch.computeBotIdentity()
return nil
}
// validateSessionMode checks that SessionMode holds a supported value.
func (ch *IMChannel) validateSessionMode() error {
switch SessionMode(ch.SessionMode) {
case SessionModeUser, SessionModeThread:
return nil
default:
return fmt.Errorf("invalid session_mode: %s", ch.SessionMode)
}
}
// computeBotIdentity derives a unique bot identity string from the channel's
// platform, mode, and credentials. Returns "" if no identity can be extracted.
func (ch *IMChannel) computeBotIdentity() string {
@@ -123,6 +147,7 @@ type ChannelSession struct {
Platform string `json:"platform" gorm:"type:varchar(20);not null"`
UserID string `json:"user_id" gorm:"type:varchar(128);not null"`
ChatID string `json:"chat_id" gorm:"type:varchar(128);not null;default:''"`
ThreadID string `json:"thread_id" gorm:"type:varchar(128);not null;default:''"`
SessionID string `json:"session_id" gorm:"type:varchar(36);not null;index"`
TenantID uint64 `json:"tenant_id" gorm:"not null;index"`
AgentID string `json:"agent_id" gorm:"type:varchar(36);default:''"`
+153
View File
@@ -0,0 +1,153 @@
package im
import (
"testing"
"gorm.io/gorm"
)
func TestValidateSessionMode(t *testing.T) {
tests := []struct {
name string
sessionMode string
wantErr bool
}{
{"user mode", "user", false},
{"thread mode", "thread", false},
{"empty defaults to user in BeforeCreate", "", false},
{"invalid mode", "invalid", true},
{"random string", "foo", true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ch := &IMChannel{SessionMode: tt.sessionMode}
err := ch.validateSessionMode()
if tt.sessionMode == "" {
// empty is handled by BeforeCreate, not validateSessionMode
// validateSessionMode treats empty as invalid
if err == nil {
t.Error("expected error for empty session_mode in validateSessionMode")
}
return
}
if (err != nil) != tt.wantErr {
t.Errorf("validateSessionMode(%q) error = %v, wantErr %v", tt.sessionMode, err, tt.wantErr)
}
})
}
}
func TestIMChannelBeforeCreate_SessionModeDefault(t *testing.T) {
tests := []struct {
name string
inputMode string
expectedMode string
}{
{"empty defaults to user", "", "user"},
{"user preserved", "user", "user"},
{"thread preserved", "thread", "thread"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ch := &IMChannel{
TenantID: 1,
AgentID: "agent-1",
Platform: "slack",
SessionMode: tt.inputMode,
Credentials: []byte("{}"),
}
err := ch.BeforeCreate(&gorm.DB{})
if err != nil {
t.Fatalf("BeforeCreate error: %v", err)
}
if ch.SessionMode != tt.expectedMode {
t.Errorf("SessionMode = %q, want %q", ch.SessionMode, tt.expectedMode)
}
})
}
}
func TestIMChannelBeforeCreate_InvalidSessionMode(t *testing.T) {
ch := &IMChannel{
TenantID: 1,
AgentID: "agent-1",
Platform: "slack",
SessionMode: "invalid",
Credentials: []byte("{}"),
}
err := ch.BeforeCreate(&gorm.DB{})
if err == nil {
t.Error("expected error for invalid session_mode")
}
}
func TestIMChannelBeforeSave_SessionModeValidation(t *testing.T) {
tests := []struct {
name string
sessionMode string
wantMode string
wantErr bool
}{
{"empty defaults to user", "", "user", false},
{"user preserved", "user", "user", false},
{"thread preserved", "thread", "thread", false},
{"invalid rejected", "invalid", "", true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ch := &IMChannel{
SessionMode: tt.sessionMode,
Credentials: []byte("{}"),
}
err := ch.BeforeSave(&gorm.DB{})
if tt.wantErr {
if err == nil {
t.Error("expected error")
}
return
}
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if ch.SessionMode != tt.wantMode {
t.Errorf("SessionMode = %q, want %q", ch.SessionMode, tt.wantMode)
}
})
}
}
func TestSessionModeConstants(t *testing.T) {
if SessionModeUser != "user" {
t.Errorf("SessionModeUser = %q, want %q", SessionModeUser, "user")
}
if SessionModeThread != "thread" {
t.Errorf("SessionModeThread = %q, want %q", SessionModeThread, "thread")
}
}
func TestChannelSessionThreadIDField(t *testing.T) {
cs := ChannelSession{
Platform: "slack",
UserID: "U123",
ChatID: "C456",
ThreadID: "1234567890.123456",
}
if cs.ThreadID != "1234567890.123456" {
t.Errorf("ThreadID = %q, want %q", cs.ThreadID, "1234567890.123456")
}
// empty ThreadID for user-mode sessions
csUser := ChannelSession{
Platform: "slack",
UserID: "U123",
ChatID: "C456",
}
if csUser.ThreadID != "" {
t.Errorf("ThreadID = %q, want empty", csUser.ThreadID)
}
}
+22 -16
View File
@@ -25,11 +25,11 @@ type ProviderSpec struct {
// chatProviderSpecs is the ordered list of provider specs.
// Order matters: more specific specs (with ModelMatcher) should come before generic ones.
var chatProviderSpecs = []ProviderSpec{
// Qwen3 (must be before generic Aliyun — only matches Qwen3 models)
// Aliyun Qwen Thinking Models (must be before generic Aliyun)
{
Provider: provider.ProviderAliyun,
ModelMatcher: func(name string) bool { return provider.IsQwen3Model(name) },
RequestCustomizer: qwen3RequestCustomizer,
ModelMatcher: func(name string) bool { return provider.IsQwenThinkingModel(name) },
RequestCustomizer: qwenThinkingRequestCustomizer,
},
// LKEAP
{
@@ -53,8 +53,8 @@ var chatProviderSpecs = []ProviderSpec{
},
// NVIDIA
{
Provider: provider.ProviderNvidia,
EndpointCustomizer: nvidiaEndpointCustomizer,
Provider: provider.ProviderNvidia,
RequestCustomizer: genericRequestCustomizer,
},
}
@@ -95,12 +95,12 @@ type ThinkingChatCompletionRequest struct {
// --- Customizer functions ---
// qwen3RequestCustomizer 自定义 Qwen3 请求
// Qwen3 模型在非流式请求时需要显式禁用 thinking
func qwen3RequestCustomizer(
req *openai.ChatCompletionRequest, _ *ChatOptions, isStream bool,
// qwenThinkingRequestCustomizer 自定义 Qwen 系列(阿里云)模型的思考请求
func qwenThinkingRequestCustomizer(
req *openai.ChatCompletionRequest, opts *ChatOptions, isStream bool,
) (any, bool) {
if !isStream {
// Qwen3 模型在非流式请求时需要显式禁用 thinking
qwenReq := QwenChatCompletionRequest{
ChatCompletionRequest: *req,
}
@@ -108,7 +108,19 @@ func qwen3RequestCustomizer(
qwenReq.EnableThinking = &enableThinking
return qwenReq, true
}
return nil, false
// 流式请求:根据 opts.Thinking 启用思考
qwenReq := QwenChatCompletionRequest{
ChatCompletionRequest: *req,
}
thinking := false
if opts != nil && opts.Thinking != nil {
thinking = *opts.Thinking
}
qwenReq.EnableThinking = &thinking
// 必须返回 true 以使用 raw HTTP,否则 SDK 会过滤掉 enable_thinking 字段
return qwenReq, true
}
// lkeapRequestCustomizer 自定义 LKEAP 请求
@@ -183,9 +195,3 @@ func volcengineRequestCustomizer(
return vcReq, true
}
// nvidiaEndpointCustomizer 自定义 NVIDIA 请求地址
// NVIDIA 模型使用 BaseURL 作为完整请求地址
func nvidiaEndpointCustomizer(baseURL string, _ string, _ bool) string {
return baseURL
}
+1
View File
@@ -22,6 +22,7 @@ import (
// Uses SSRFSafeDialContext to prevent DNS rebinding attacks at the connection layer.
var rawHTTPClient = &http.Client{
Transport: &http.Transport{
Proxy: http.ProxyFromEnvironment,
DialContext: secutils.SSRFSafeDialContext,
TLSHandshakeTimeout: 10 * time.Second,
IdleConnTimeout: 90 * time.Second,
+8 -4
View File
@@ -54,10 +54,14 @@ func (p *AliyunProvider) ValidateConfig(config *Config) error {
return nil
}
// IsQwen3Model 检查模型名是否为 Qwen3 模型
// Qwen3 模型需要特殊处理 enable_thinking 参数
func IsQwen3Model(modelName string) bool {
return strings.HasPrefix(modelName, "qwen3-")
// IsQwenThinkingModel 检查模型名是否为支持思维链的 Qwen 模型
// 支持思维链的模型需要特殊处理 enable_thinking 参数
func IsQwenThinkingModel(modelName string) bool {
lowerName := strings.ToLower(modelName)
return strings.HasPrefix(lowerName, "qwen3") ||
strings.HasPrefix(lowerName, "qwen-plus") ||
strings.HasPrefix(lowerName, "qwen-max") ||
strings.HasPrefix(lowerName, "qwen-turbo")
}
// IsDeepSeekModel 检查模型名是否为 DeepSeek 模型
+2 -4
View File
@@ -8,9 +8,7 @@ import (
const (
// NvidiaChatBaseURL NVIDIA Chat 的默认 BaseURL
NvidiaChatBaseURL = "https://integrate.api.nvidia.com/v1/chat/completions"
// NvidiaVLMBaseURL NVIDIA VLM 的默认 BaseURL
NvidiaVLMBaseURL = "https://integrate.api.nvidia.com/v1"
NvidiaChatBaseURL = "https://integrate.api.nvidia.com/v1"
// NvidiaRerankBaseURL NVIDIA Rerank 的默认 BaseURL
NvidiaRerankBaseURL = "https://ai.api.nvidia.com/v1/retrieval/nvidia/reranking"
)
@@ -32,7 +30,7 @@ func (p *NvidiaProvider) Info() ProviderInfo {
types.ModelTypeKnowledgeQA: NvidiaChatBaseURL,
types.ModelTypeEmbedding: NvidiaChatBaseURL,
types.ModelTypeRerank: NvidiaRerankBaseURL,
types.ModelTypeVLLM: NvidiaVLMBaseURL,
types.ModelTypeVLLM: NvidiaChatBaseURL,
},
ModelTypes: []types.ModelType{
types.ModelTypeKnowledgeQA,
+4
View File
@@ -54,6 +54,10 @@ type AgentConfig struct {
// The agent compresses older messages to stay within this limit,
// preserving tool_call/tool_result pairs.
MaxContextTokens int `json:"max_context_tokens,omitempty"`
// Whether to execute independent tool calls in parallel (default: false).
// When enabled and the LLM returns multiple tool calls, they run concurrently via errgroup.
ParallelToolCalls bool `json:"parallel_tool_calls,omitempty"`
}
// SessionAgentConfig represents session-level agent configuration
+5 -4
View File
@@ -47,7 +47,8 @@ const (
ModelSourceSiliconFlow ModelSource = "siliconflow" // SiliconFlow model
ModelSourceJina ModelSource = "jina" // Jina AI model
ModelSourceOpenRouter ModelSource = "openrouter" // OpenRouter model
ModelSourceNovita ModelSource = "novita" // Novita AI model
ModelSourceNvidia ModelSource = "nvidia" // NVIDIA model
ModelSourceNovita ModelSource = "novita" // Novita AI model
)
// EmbeddingParameters represents the embedding parameters for a model
@@ -61,9 +62,9 @@ type ModelParameters struct {
APIKey string `yaml:"api_key" json:"api_key"`
InterfaceType string `yaml:"interface_type" json:"interface_type"`
EmbeddingParameters EmbeddingParameters `yaml:"embedding_parameters" json:"embedding_parameters"`
ParameterSize string `yaml:"parameter_size" json:"parameter_size"` // Ollama model parameter size (e.g., "7B", "13B", "70B")
Provider string `yaml:"provider" json:"provider"` // Provider identifier: openai, aliyun, zhipu, generic
ExtraConfig map[string]string `yaml:"extra_config" json:"extra_config"` // Provider-specific configuration
ParameterSize string `yaml:"parameter_size" json:"parameter_size"` // Ollama model parameter size (e.g., "7B", "13B", "70B")
Provider string `yaml:"provider" json:"provider"` // Provider identifier: openai, aliyun, zhipu, generic
ExtraConfig map[string]string `yaml:"extra_config" json:"extra_config"` // Provider-specific configuration
SupportsVision bool `yaml:"supports_vision" json:"supports_vision"` // Whether the model accepts image/multimodal input
}
+22 -1
View File
@@ -14,6 +14,8 @@ import (
"sync"
"time"
"unicode/utf8"
"golang.org/x/net/http/httpproxy"
)
// XSS 防护相关正则表达式
@@ -781,7 +783,7 @@ func SSRFSafeDialContext(ctx context.Context, network, addr string) (net.Conn, e
// Whitelisted hosts bypass all dial-time SSRF checks, consistent with
// ValidateURLForSSRF which skips IsSSRFSafeURL for whitelisted hosts.
if IsSSRFWhitelisted(host) {
if IsSystemProxy(addr) || IsSSRFWhitelisted(host) {
dialer := &net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
@@ -978,3 +980,22 @@ func ValidateURLForSSRF(rawURL string) error {
}
return nil
}
// IsSystemProxy 判断是否为系统代理
func IsSystemProxy(host string) bool {
proxyCfg := httpproxy.FromEnvironment()
for _, proxyUrl := range []string{
proxyCfg.HTTPProxy,
proxyCfg.HTTPSProxy,
} {
if proxyUrl == "" {
continue
}
if parse, err := url.Parse(proxyUrl); err == nil {
if parse.Host == host {
return true
}
}
}
return false
}
@@ -0,0 +1,8 @@
DO $$ BEGIN RAISE NOTICE '[Migration 000028] Rolling back thread session support'; END $$;
DROP INDEX IF EXISTS idx_channel_thread_lookup;
ALTER TABLE im_channel_sessions DROP COLUMN IF EXISTS thread_id;
ALTER TABLE im_channels DROP CONSTRAINT IF EXISTS chk_im_channels_session_mode;
ALTER TABLE im_channels DROP COLUMN IF EXISTS session_mode;
DO $$ BEGIN RAISE NOTICE '[Migration 000028] Rollback completed'; END $$;
@@ -0,0 +1,33 @@
-- Migration: 000028_im_thread_session
-- Description: Add thread-based session mode support for IM channels
DO $$ BEGIN RAISE NOTICE '[Migration 000028] Adding thread session support'; END $$;
-- 1. im_channels: add session_mode column
ALTER TABLE im_channels
ADD COLUMN IF NOT EXISTS session_mode VARCHAR(20) NOT NULL DEFAULT 'user';
-- 2. CHECK constraint (separate statement: ADD COLUMN IF NOT EXISTS does not support inline CONSTRAINT)
DO $$ BEGIN
ALTER TABLE im_channels
ADD CONSTRAINT chk_im_channels_session_mode
CHECK (session_mode IN ('user', 'thread'));
EXCEPTION WHEN duplicate_object THEN NULL;
END $$;
COMMENT ON COLUMN im_channels.session_mode IS
'Session resolution mode: user (per user+chat, default) or thread (per thread)';
-- 3. im_channel_sessions: add thread_id column
ALTER TABLE im_channel_sessions
ADD COLUMN IF NOT EXISTS thread_id VARCHAR(128) NOT NULL DEFAULT '';
COMMENT ON COLUMN im_channel_sessions.thread_id IS
'Platform thread identifier for thread-based sessions. Empty for user-mode sessions.';
-- 4. Unique index for thread-mode session lookup
-- Includes chat_id because Telegram message_thread_id is per-chat (topic ID within a group).
CREATE UNIQUE INDEX IF NOT EXISTS idx_channel_thread_lookup
ON im_channel_sessions (platform, chat_id, thread_id, tenant_id)
WHERE deleted_at IS NULL AND thread_id != '';
DO $$ BEGIN RAISE NOTICE '[Migration 000028] Thread session support added'; END $$;