Fully autonomous AI Agents system capable of performing complex penetration testing tasks
Go ai-agentsai-security-toolanthropicautonomous-agentsgolanggptgraphqlmulti-agent-systemoffensive-securityopen-sourceopenaipenetration-testingpenetration-testing-toolsreactsecurity-automationsecurity-testingsecurity-toolsself-hosted
feat(knowledge): add pgvector knowledge base management
Dmitry Ng3a5207927856
diff --git a/backend/cmd/ftester/mocks/logs.go b/backend/cmd/ftester/mocks/logs.goindex d3cd0c52..71b75385 100644--- a/backend/cmd/ftester/mocks/logs.go+++ b/backend/cmd/ftester/mocks/logs.go@@ -3,8 +3,10 @@ package mocksimport ("context""encoding/json"+ "fmt""pentagi/pkg/database"+ "pentagi/pkg/graph/model""pentagi/pkg/terminal""pentagi/pkg/tools")@@ -16,27 +18,30 @@ type ProxyProviders interface {GetSearchLogProvider() tools.SearchLogProviderGetTermLogProvider() tools.TermLogProviderGetVectorStoreLogProvider() tools.VectorStoreLogProvider+ GetKnowledgeProvider() tools.KnowledgeProvider}// proxyProviders contains all the proxy implementations for various providerstype proxyProviders struct {- screenshot *proxyScreenshotProvider- agentLog *proxyAgentLogProvider- msgLog *proxyMsgLogProvider- searchLog *proxySearchLogProvider- termLog *proxyTermLogProvider- vectorStoreLog *proxyVectorStoreLogProvider+ screenshot *proxyScreenshotProvider+ agentLog *proxyAgentLogProvider+ msgLog *proxyMsgLogProvider+ searchLog *proxySearchLogProvider+ termLog *proxyTermLogProvider+ vectorStoreLog *proxyVectorStoreLogProvider+ knowledgeProvider *proxyKnowledgeProvider}// NewProxyProviders creates a new set of proxy providersfunc NewProxyProviders() ProxyProviders {return &proxyProviders{- screenshot: &proxyScreenshotProvider{},- agentLog: &proxyAgentLogProvider{},- msgLog: &proxyMsgLogProvider{},- searchLog: &proxySearchLogProvider{},- termLog: &proxyTermLogProvider{},- vectorStoreLog: &proxyVectorStoreLogProvider{},+ screenshot: &proxyScreenshotProvider{},+ agentLog: &proxyAgentLogProvider{},+ msgLog: &proxyMsgLogProvider{},+ searchLog: &proxySearchLogProvider{},+ termLog: &proxyTermLogProvider{},+ vectorStoreLog: &proxyVectorStoreLogProvider{},+ knowledgeProvider: &proxyKnowledgeProvider{},}}@@ -64,6 +69,10 @@ func (p *proxyProviders) GetVectorStoreLogProvider() tools.VectorStoreLogProvidereturn p.vectorStoreLog}+func (p *proxyProviders) GetKnowledgeProvider() tools.KnowledgeProvider {+ return p.knowledgeProvider+}+// proxyScreenshotProvider is a proxy implementation of ScreenshotProvidertype proxyScreenshotProvider struct{}@@ -259,3 +268,40 @@ func (p *proxyVectorStoreLogProvider) PutLog(return 0, nil}++// proxyKnowledgeProvider is a proxy implementation of KnowledgeProvider+type proxyKnowledgeProvider struct{}++// KnowledgeDocumentCreated implements the KnowledgeProvider interface+func (p *proxyKnowledgeProvider) KnowledgeDocumentCreated(ctx context.Context, doc *model.KnowledgeDocument) {+ terminal.PrintInfo("Knowledge document created:")+ terminal.PrintKeyValue("ID", doc.ID)+ terminal.PrintKeyValue("Type", string(doc.DocType))+ terminal.PrintKeyValue("Content", doc.Content)+ terminal.PrintKeyValue("Question", doc.Question)+ if doc.Description != nil {+ terminal.PrintKeyValue("Description", *doc.Description)+ }+ if doc.FlowID != nil {+ terminal.PrintKeyValueFormat("Flow ID", "%d", *doc.FlowID)+ }+ if doc.TaskID != nil {+ terminal.PrintKeyValueFormat("Task ID", "%d", *doc.TaskID)+ }+ if doc.SubtaskID != nil {+ terminal.PrintKeyValueFormat("Subtask ID", "%d", *doc.SubtaskID)+ }+ if doc.GuideType != nil {+ terminal.PrintKeyValue("Guide Type", string(*doc.GuideType))+ }+ if doc.AnswerType != nil {+ terminal.PrintKeyValue("Answer Type", string(*doc.AnswerType))+ }+ if doc.CodeLang != nil {+ terminal.PrintKeyValue("Code Lang", *doc.CodeLang)+ }+ terminal.PrintKeyValueFormat("Part Size", "%d", doc.PartSize)+ terminal.PrintKeyValueFormat("Total Size", "%d", doc.TotalSize)+ terminal.PrintKeyValue("Manual", fmt.Sprintf("%t", doc.Manual))+ terminal.PrintKeyValueFormat("User ID", "%d", doc.UserID)+}diff --git a/backend/cmd/ftester/worker/executor.go b/backend/cmd/ftester/worker/executor.goindex 70e99276..2cdb5dcf 100644--- a/backend/cmd/ftester/worker/executor.go+++ b/backend/cmd/ftester/worker/executor.go@@ -48,6 +48,7 @@ type toolExecutor struct {store *pgvector.StoregraphitiClient *graphiti.Clientproxies mocks.ProxyProviders+ userID int64flowID int64taskID *int64subtaskID *int64@@ -61,7 +62,7 @@ func newToolExecutor(dockerClient docker.DockerClient,handlers providers.FlowProviderHandlers,proxies mocks.ProxyProviders,- flowID int64,+ userID, flowID int64,taskID, subtaskID *int64,embedder embeddings.Embedder,graphitiClient *graphiti.Client,@@ -72,6 +73,7 @@ func newToolExecutor(context.Background(),pgvector.WithConnectionURL(cfg.DatabaseURL),pgvector.WithEmbedder(embedder),+ pgvector.WithCollectionName("langchain"),)if err != nil {logrus.WithError(err).Error("failed to create pgvector store")@@ -103,6 +105,7 @@ func newToolExecutor(store: store,graphitiClient: graphitiClient,proxies: proxies,+ userID: userID,flowID: flowID,taskID: taskID,subtaskID: subtaskID,@@ -238,32 +241,38 @@ func (te *toolExecutor) GetTool(ctx context.Context, funcName string) (tools.Toocase tools.SearchGuideToolName:return tools.NewGuideTool(+ te.userID,te.flowID,te.taskID,te.subtaskID,te.replacer,te.store,te.proxies.GetVectorStoreLogProvider(),+ te.proxies.GetKnowledgeProvider(),), nilcase tools.SearchAnswerToolName:return tools.NewSearchTool(+ te.userID,te.flowID,te.taskID,te.subtaskID,te.replacer,te.store,te.proxies.GetVectorStoreLogProvider(),+ te.proxies.GetKnowledgeProvider(),), nilcase tools.SearchCodeToolName:return tools.NewCodeTool(+ te.userID,te.flowID,te.taskID,te.subtaskID,te.replacer,te.store,te.proxies.GetVectorStoreLogProvider(),+ te.proxies.GetKnowledgeProvider(),), nilcase tools.GraphitiSearchToolName:diff --git a/backend/cmd/ftester/worker/tester.go b/backend/cmd/ftester/worker/tester.goindex 673db4fc..524a2467 100644--- a/backend/cmd/ftester/worker/tester.go+++ b/backend/cmd/ftester/worker/tester.go@@ -66,7 +66,7 @@ func NewTester(functions := &tools.Functions{}// Initialize tools flowExecutor- flowExecutor, err := tools.NewFlowToolsExecutor(db, cfg, dockerClient, functions, flowID)+ flowExecutor, err := tools.NewFlowToolsExecutor(db, cfg, dockerClient, functions, userID, flowID)if err != nil {return nil, fmt.Errorf("failed to create flow tools executor: %w", err)}@@ -81,12 +81,13 @@ func NewTester(flowExecutor.SetSearchLogProvider(proxies.GetSearchLogProvider())flowExecutor.SetTermLogProvider(proxies.GetTermLogProvider())flowExecutor.SetVectorStoreLogProvider(proxies.GetVectorStoreLogProvider())+ flowExecutor.SetKnowledgeProvider(proxies.GetKnowledgeProvider())flowExecutor.SetGraphitiClient(providerController.GraphitiClient())// Initialize tool executortoolExecutor, err := newToolExecutor(flowExecutor, cfg, db, dockerClient, nil, proxies,- flowID, taskID, subtaskID, providerController.Embedder(),+ userID, flowID, taskID, subtaskID, providerController.Embedder(),providerController.GraphitiClient(),)if err != nil {diff --git a/backend/go.mod b/backend/go.modindex 5394abd1..4a31f836 100644--- a/backend/go.mod+++ b/backend/go.mod@@ -45,6 +45,7 @@ require (github.com/rivo/uniseg v0.4.7github.com/shirou/gopsutil/v3 v3.24.5github.com/sirupsen/logrus v1.9.3+ github.com/sqlc-dev/pqtype v0.3.0github.com/stretchr/testify v1.11.1github.com/swaggo/gin-swagger v1.3.0github.com/swaggo/swag v1.8.7diff --git a/backend/go.sum b/backend/go.sumindex 402f4193..ee265fa3 100644--- a/backend/go.sum+++ b/backend/go.sum@@ -555,6 +555,8 @@ github.com/sosodev/duration v1.3.1 h1:qtHBDMQ6lvMQsL15g4aopM4HEfOaYuhWBw3NPTtlqqgithub.com/sosodev/duration v1.3.1/go.mod h1:RQIBBX0+fMLc/D9+Jb/fwvVmo0eZvDDEERAikUR6SDg=github.com/spf13/cast v1.3.1 h1:nFm6S0SMdyzrzcmThSipiEubIDy8WEXKNZ0UOgiRpng=github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=+github.com/sqlc-dev/pqtype v0.3.0 h1:b09TewZ3cSnO5+M1Kqq05y0+OjqIptxELaSayg7bmqk=+github.com/sqlc-dev/pqtype v0.3.0/go.mod h1:oyUjp5981ctiL9UYvj1bVvCKi8OXkCa0u645hce7CAs=github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=diff --git a/backend/migrations/sql/20260501_120000_knowledge.sql b/backend/migrations/sql/20260501_120000_knowledge.sqlnew file mode 100644index 00000000..6977d5ad--- /dev/null+++ b/backend/migrations/sql/20260501_120000_knowledge.sql@@ -0,0 +1,108 @@+-- +goose Up+-- +goose StatementBegin++INSERT INTO privileges (role_id, name) VALUES+ (1, 'knowledge.admin'),+ (1, 'knowledge.view'),+ (1, 'knowledge.create'),+ (1, 'knowledge.edit'),+ (1, 'knowledge.delete'),+ (1, 'knowledge.search'),+ (1, 'knowledge.subscribe'),+ (2, 'knowledge.view'),+ (2, 'knowledge.create'),+ (2, 'knowledge.edit'),+ (2, 'knowledge.delete'),+ (2, 'knowledge.search'),+ (2, 'knowledge.subscribe')+ ON CONFLICT DO NOTHING;++-- Ensure the vector extension is present (langchaingo also creates it, but migrations+-- run before any flow starts, so we need it here for the backfill UPDATE below).+CREATE EXTENSION IF NOT EXISTS vector;++-- Logical namespace for embeddings.+-- DDL kept identical to what langchaingo's createCollectionTableIfNotExists generates+-- so IF NOT EXISTS is a true no-op when the table already exists.+CREATE TABLE IF NOT EXISTS langchain_pg_collection (+ name varchar,+ cmetadata json,+ "uuid" uuid NOT NULL,+ UNIQUE (name),+ PRIMARY KEY ("uuid")+);++-- Physical storage for chunked text, vector embeddings and per-document metadata.+-- DDL kept identical to what langchaingo's createEmbeddingTableIfNotExists generates.+CREATE TABLE IF NOT EXISTS langchain_pg_embedding (+ collection_id uuid,+ embedding vector,+ document varchar,+ cmetadata json,+ "uuid" uuid NOT NULL,+ CONSTRAINT langchain_pg_embedding_collection_id_fkey+ FOREIGN KEY (collection_id)+ REFERENCES langchain_pg_collection ("uuid") ON DELETE CASCADE,+ PRIMARY KEY ("uuid")+);++CREATE INDEX IF NOT EXISTS langchain_pg_embedding_collection_id+ ON langchain_pg_embedding (collection_id);++-- Step 1: Backfill user_id from flows for documents whose flow still exists.+-- Documents whose flow_id has no matching row are left with user_id NULL.+UPDATE langchain_pg_embedding e+SET cmetadata = (e.cmetadata::jsonb || jsonb_build_object('user_id', f.user_id))::json+FROM langchain_pg_collection c, flows f+WHERE e.collection_id = c.uuid+ AND c.name = 'langchain'+ AND (e.cmetadata ->> 'flow_id') IS NOT NULL+ AND (e.cmetadata ->> 'user_id') IS NULL+ AND f.id = (e.cmetadata ->> 'flow_id')::bigint;++-- Step 2: For any remaining documents still missing user_id (no flow_id, deleted+-- flow, or manually created before user tracking), default to user_id = 1.+UPDATE langchain_pg_embedding e+SET cmetadata = (e.cmetadata::jsonb || jsonb_build_object('user_id', 1))::json+FROM langchain_pg_collection c+WHERE e.collection_id = c.uuid+ AND c.name = 'langchain'+ AND (e.cmetadata ->> 'user_id') IS NULL;++-- Purge accumulated memory documents from the vector store that belong to flows+-- which have already been soft-deleted (deleted_at IS NOT NULL) or no longer exist+-- in the flows table at all.+--+-- These documents are never queried again after their flow is gone, so keeping them+-- only wastes storage and degrades vector search performance.+--+-- The flows table uses soft deletes:+-- UPDATE flows SET deleted_at = CURRENT_TIMESTAMP WHERE id = $1+-- so the condition covers both hard-missing rows and soft-deleted ones.+DELETE FROM langchain_pg_embedding e+USING langchain_pg_collection c+WHERE e.collection_id = c.uuid+ AND c.name = 'langchain'+ AND COALESCE(e.cmetadata ->> 'doc_type', '') = 'memory'+ AND (e.cmetadata ->> 'flow_id') IS NOT NULL+ AND NOT EXISTS (+ SELECT 1+ FROM flows f+ WHERE f.id = (e.cmetadata ->> 'flow_id')::bigint+ AND f.deleted_at IS NULL+ );++-- +goose StatementEnd++-- +goose Down+-- +goose StatementBegin++DELETE FROM privileges WHERE name LIKE 'knowledge.%';++-- The langchain tables are intentionally NOT dropped in Down:+-- they hold production knowledge data managed by the pgvector store.++-- The deleted memory documents cannot be recovered (the embedding data is gone).+-- Down migration is intentionally a no-op.++-- +goose StatementEnddiff --git a/backend/pkg/controller/assistant.go b/backend/pkg/controller/assistant.goindex 44e257cb..052fec24 100644--- a/backend/pkg/controller/assistant.go+++ b/backend/pkg/controller/assistant.go@@ -159,7 +159,7 @@ func NewAssistantWorker(ctx context.Context, awc newAssistantWorkerCtx) (Assista}prompter := templates.NewDefaultPrompter() // TODO: change to flow prompter by userID from DB- executor, err := tools.NewFlowToolsExecutor(awc.db, awc.cfg, awc.docker, awc.functions, awc.flowID)+ executor, err := tools.NewFlowToolsExecutor(awc.db, awc.cfg, awc.docker, awc.functions, awc.userID, awc.flowID)if err != nil {return nil, wrapErrorEndSpan(ctx, assistantSpan, "failed to create flow tools executor", err)}@@ -214,6 +214,7 @@ func NewAssistantWorker(ctx context.Context, awc newAssistantWorkerCtx) (Assistaexecutor.SetSearchLogProvider(workers.slw)executor.SetTermLogProvider(workers.tlw)executor.SetVectorStoreLogProvider(workers.vslw)+ executor.SetKnowledgeProvider(pub)executor.SetGraphitiClient(awc.provs.GraphitiClient())ctx, cancel := context.WithCancel(context.Background())@@ -326,7 +327,7 @@ func LoadAssistantWorker(}prompter := templates.NewDefaultPrompter() // TODO: change to flow prompter by userID from DB- executor, err := tools.NewFlowToolsExecutor(awc.db, awc.cfg, awc.docker, functions, awc.flowID)+ executor, err := tools.NewFlowToolsExecutor(awc.db, awc.cfg, awc.docker, functions, awc.userID, awc.flowID)if err != nil {return nil, wrapErrorEndSpan(ctx, assistantSpan, "failed to create flow tools executor", err)}@@ -354,6 +355,7 @@ func LoadAssistantWorker(executor.SetSearchLogProvider(workers.slw)executor.SetTermLogProvider(workers.tlw)executor.SetVectorStoreLogProvider(workers.vslw)+ executor.SetKnowledgeProvider(pub)var msgChainID int64pmsgChainID := database.NullInt64ToInt64(assistant.MsgchainID)diff --git a/backend/pkg/controller/flow.go b/backend/pkg/controller/flow.goindex ea8f3e0f..641cc099 100644--- a/backend/pkg/controller/flow.go+++ b/backend/pkg/controller/flow.go@@ -177,7 +177,7 @@ func NewFlowWorker(ctx, _ = flowSpan.Observation(ctx)prompter := templates.NewDefaultPrompter() // TODO: change to flow prompter by userID from DB- executor, err := tools.NewFlowToolsExecutor(fwc.db, fwc.cfg, fwc.docker, fwc.functions, flow.ID)+ executor, err := tools.NewFlowToolsExecutor(fwc.db, fwc.cfg, fwc.docker, fwc.functions, fwc.userID, flow.ID)if err != nil {return nil, wrapErrorEndSpan(ctx, flowSpan, "failed to create flow tools executor", err)}@@ -223,6 +223,7 @@ func NewFlowWorker(executor.SetSearchLogProvider(workers.slw)executor.SetTermLogProvider(workers.tlw)executor.SetVectorStoreLogProvider(workers.vslw)+ executor.SetKnowledgeProvider(pub)executor.SetGraphitiClient(fwc.provs.GraphitiClient())flowCtx := &FlowContext{@@ -345,7 +346,7 @@ func LoadFlowWorker(ctx context.Context, flow database.Flow, fwc flowWorkerCtx)}prompter := templates.NewDefaultPrompter() // TODO: change to flow prompter by userID from DB- executor, err := tools.NewFlowToolsExecutor(fwc.db, fwc.cfg, fwc.docker, functions, flow.ID)+ executor, err := tools.NewFlowToolsExecutor(fwc.db, fwc.cfg, fwc.docker, functions, flow.UserID, flow.ID)if err != nil {return nil, wrapErrorEndSpan(ctx, flowSpan, "failed to create flow tools executor", err)}@@ -375,6 +376,7 @@ func LoadFlowWorker(ctx context.Context, flow database.Flow, fwc flowWorkerCtx)executor.SetSearchLogProvider(workers.slw)executor.SetTermLogProvider(workers.tlw)executor.SetVectorStoreLogProvider(workers.vslw)+ executor.SetKnowledgeProvider(pub)executor.SetGraphitiClient(fwc.provs.GraphitiClient())flowCtx := &FlowContext{diff --git a/backend/pkg/database/knowledge.sql.go b/backend/pkg/database/knowledge.sql.gonew file mode 100644index 00000000..ddbfb7bf--- /dev/null+++ b/backend/pkg/database/knowledge.sql.go@@ -0,0 +1,285 @@+// Code generated by sqlc. DO NOT EDIT.+// versions:+// sqlc v1.27.0+// source: knowledge.sql++package database++import (+ "context"+ "database/sql"++ "github.com/sqlc-dev/pqtype"+)++const deleteFlowMemoryDocuments = `-- name: DeleteFlowMemoryDocuments :exec+DELETE FROM langchain_pg_embedding+WHERE collection_id = (SELECT uuid FROM langchain_pg_collection WHERE name = 'langchain')+ AND COALESCE(cmetadata ->> 'doc_type', '') = 'memory'+ AND (cmetadata ->> 'flow_id') = $1+`++// Delete all memory-type documents for a specific flow.+// Called on flow deletion to free long-term memory that will never be re-used.+// $1 is the decimal text representation of the flow ID (e.g. "55"), matching the+// text result of (cmetadata ->> 'flow_id') which uses JSON ->> extraction.+func (q *Queries) DeleteFlowMemoryDocuments(ctx context.Context, dollar_1 sql.NullString) error {+ _, err := q.db.ExecContext(ctx, deleteFlowMemoryDocuments, dollar_1)+ return err+}++const deleteKnowledgeDocument = `-- name: DeleteKnowledgeDocument :exec+DELETE FROM langchain_pg_embedding+WHERE uuid::text = $1+ AND collection_id = (SELECT uuid FROM langchain_pg_collection WHERE name = 'langchain')+`++// Delete a knowledge document by UUID (admin — no user_id check).+func (q *Queries) DeleteKnowledgeDocument(ctx context.Context, dollar_1 sql.NullString) error {+ _, err := q.db.ExecContext(ctx, deleteKnowledgeDocument, dollar_1)+ return err+}++const deleteUserKnowledgeDocument = `-- name: DeleteUserKnowledgeDocument :exec+DELETE FROM langchain_pg_embedding+WHERE uuid::text = $1+ AND (cmetadata ->> 'user_id') = $2+ AND collection_id = (SELECT uuid FROM langchain_pg_collection WHERE name = 'langchain')+`++type DeleteUserKnowledgeDocumentParams struct {+ Column1 sql.NullString `json:"column_1"`+ Column2 sql.NullString `json:"column_2"`+}++// Delete a knowledge document by UUID, only if it belongs to the given user.+func (q *Queries) DeleteUserKnowledgeDocument(ctx context.Context, arg DeleteUserKnowledgeDocumentParams) error {+ _, err := q.db.ExecContext(ctx, deleteUserKnowledgeDocument, arg.Column1, arg.Column2)+ return err+}++const getKnowledgeDocument = `-- name: GetKnowledgeDocument :one+SELECT+ e.uuid::text AS id,+ COALESCE(e.document, '') AS document,+ COALESCE(e.cmetadata::text, '{}') AS cmetadata+FROM langchain_pg_embedding e+INNER JOIN langchain_pg_collection c ON e.collection_id = c.uuid+WHERE c.name = 'langchain'+ AND e.uuid::text = $1+`++type GetKnowledgeDocumentRow struct {+ ID string `json:"id"`+ Document string `json:"document"`+ Cmetadata sql.NullString `json:"cmetadata"`+}++// Fetch a single knowledge document by its UUID (admin view — no user_id check).+func (q *Queries) GetKnowledgeDocument(ctx context.Context, uuid string) (GetKnowledgeDocumentRow, error) {+ row := q.db.QueryRowContext(ctx, getKnowledgeDocument, uuid)+ var i GetKnowledgeDocumentRow+ err := row.Scan(&i.ID, &i.Document, &i.Cmetadata)+ return i, err+}++const getUserKnowledgeDocument = `-- name: GetUserKnowledgeDocument :one+SELECT+ e.uuid::text AS id,+ COALESCE(e.document, '') AS document,+ COALESCE(e.cmetadata::text, '{}') AS cmetadata+FROM langchain_pg_embedding e+INNER JOIN langchain_pg_collection c ON e.collection_id = c.uuid+WHERE c.name = 'langchain'+ AND e.uuid::text = $1+ AND (e.cmetadata ->> 'user_id') = $2+`++type GetUserKnowledgeDocumentParams struct {+ Uuid string `json:"uuid"`+ Cmetadata sql.NullString `json:"cmetadata"`+}++type GetUserKnowledgeDocumentRow struct {+ ID string `json:"id"`+ Document string `json:"document"`+ Cmetadata sql.NullString `json:"cmetadata"`+}++// Fetch a single knowledge document by UUID, scoped to a specific user.+func (q *Queries) GetUserKnowledgeDocument(ctx context.Context, arg GetUserKnowledgeDocumentParams) (GetUserKnowledgeDocumentRow, error) {+ row := q.db.QueryRowContext(ctx, getUserKnowledgeDocument, arg.Uuid, arg.Cmetadata)+ var i GetUserKnowledgeDocumentRow+ err := row.Scan(&i.ID, &i.Document, &i.Cmetadata)+ return i, err+}++const listAllKnowledgeDocuments = `-- name: ListAllKnowledgeDocuments :many+SELECT+ e.uuid::text AS id,+ COALESCE(e.document, '') AS document,+ COALESCE(e.cmetadata::text, '{}') AS cmetadata+FROM langchain_pg_embedding e+INNER JOIN langchain_pg_collection c ON e.collection_id = c.uuid+WHERE c.name = 'langchain'+ AND COALESCE(e.cmetadata ->> 'doc_type', '') NOT IN ('memory')+ORDER BY e.uuid+`++type ListAllKnowledgeDocumentsRow struct {+ ID string `json:"id"`+ Document string `json:"document"`+ Cmetadata sql.NullString `json:"cmetadata"`+}++// List all knowledge documents excluding the noisy memory type (admin view).+func (q *Queries) ListAllKnowledgeDocuments(ctx context.Context) ([]ListAllKnowledgeDocumentsRow, error) {+ rows, err := q.db.QueryContext(ctx, listAllKnowledgeDocuments)+ if err != nil {+ return nil, err+ }+ defer rows.Close()+ var items []ListAllKnowledgeDocumentsRow+ for rows.Next() {+ var i ListAllKnowledgeDocumentsRow+ if err := rows.Scan(&i.ID, &i.Document, &i.Cmetadata); err != nil {+ return nil, err+ }+ items = append(items, i)+ }+ if err := rows.Close(); err != nil {+ return nil, err+ }+ if err := rows.Err(); err != nil {+ return nil, err+ }+ return items, nil+}++const listFlowKnowledgeDocuments = `-- name: ListFlowKnowledgeDocuments :many+SELECT+ e.uuid::text AS id,+ COALESCE(e.document, '') AS document,+ COALESCE(e.cmetadata::text, '{}') AS cmetadata+FROM langchain_pg_embedding e+INNER JOIN langchain_pg_collection c ON e.collection_id = c.uuid+WHERE c.name = 'langchain'+ AND COALESCE(e.cmetadata ->> 'doc_type', '') NOT IN ('memory')+ AND (e.cmetadata ->> 'flow_id') = $1+ORDER BY e.uuid+`++type ListFlowKnowledgeDocumentsRow struct {+ ID string `json:"id"`+ Document string `json:"document"`+ Cmetadata sql.NullString `json:"cmetadata"`+}++// List non-memory knowledge documents belonging to a specific flow (admin scoped).+func (q *Queries) ListFlowKnowledgeDocuments(ctx context.Context, cmetadata sql.NullString) ([]ListFlowKnowledgeDocumentsRow, error) {+ rows, err := q.db.QueryContext(ctx, listFlowKnowledgeDocuments, cmetadata)+ if err != nil {+ return nil, err+ }+ defer rows.Close()+ var items []ListFlowKnowledgeDocumentsRow+ for rows.Next() {+ var i ListFlowKnowledgeDocumentsRow+ if err := rows.Scan(&i.ID, &i.Document, &i.Cmetadata); err != nil {+ return nil, err+ }+ items = append(items, i)+ }+ if err := rows.Close(); err != nil {+ return nil, err+ }+ if err := rows.Err(); err != nil {+ return nil, err+ }+ return items, nil+}++const listUserKnowledgeDocuments = `-- name: ListUserKnowledgeDocuments :many+SELECT+ e.uuid::text AS id,+ COALESCE(e.document, '') AS document,+ COALESCE(e.cmetadata::text, '{}') AS cmetadata+FROM langchain_pg_embedding e+INNER JOIN langchain_pg_collection c ON e.collection_id = c.uuid+WHERE c.name = 'langchain'+ AND COALESCE(e.cmetadata ->> 'doc_type', '') NOT IN ('memory')+ AND (e.cmetadata ->> 'user_id') = $1+ORDER BY e.uuid+`++type ListUserKnowledgeDocumentsRow struct {+ ID string `json:"id"`+ Document string `json:"document"`+ Cmetadata sql.NullString `json:"cmetadata"`+}++// List all non-memory knowledge documents owned by a specific user (user-scoped view).+func (q *Queries) ListUserKnowledgeDocuments(ctx context.Context, cmetadata sql.NullString) ([]ListUserKnowledgeDocumentsRow, error) {+ rows, err := q.db.QueryContext(ctx, listUserKnowledgeDocuments, cmetadata)+ if err != nil {+ return nil, err+ }+ defer rows.Close()+ var items []ListUserKnowledgeDocumentsRow+ for rows.Next() {+ var i ListUserKnowledgeDocumentsRow+ if err := rows.Scan(&i.ID, &i.Document, &i.Cmetadata); err != nil {+ return nil, err+ }+ items = append(items, i)+ }+ if err := rows.Close(); err != nil {+ return nil, err+ }+ if err := rows.Err(); err != nil {+ return nil, err+ }+ return items, nil+}++const updateKnowledgeDocument = `-- name: UpdateKnowledgeDocument :one+UPDATE langchain_pg_embedding+SET+ embedding = $2::vector,+ document = $3,+ cmetadata = $4::json+WHERE uuid::text = $1+ AND collection_id = (SELECT uuid FROM langchain_pg_collection WHERE name = 'langchain')+RETURNING+ uuid::text AS id,+ COALESCE(document, '') AS document,+ COALESCE(cmetadata::text, '{}') AS cmetadata+`++type UpdateKnowledgeDocumentParams struct {+ Column1 sql.NullString `json:"column_1"`+ Column2 string `json:"column_2"`+ Column3 sql.NullString `json:"column_3"`+ Column4 pqtype.NullRawMessage `json:"column_4"`+}++type UpdateKnowledgeDocumentRow struct {+ ID string `json:"id"`+ Document string `json:"document"`+ Cmetadata sql.NullString `json:"cmetadata"`+}++// Update an existing document's embedding, text and metadata atomically.+// $2 must be formatted as a PostgreSQL vector literal: '[f1,f2,...]'+// $4 must be valid JSON text.+func (q *Queries) UpdateKnowledgeDocument(ctx context.Context, arg UpdateKnowledgeDocumentParams) (UpdateKnowledgeDocumentRow, error) {+ row := q.db.QueryRowContext(ctx, updateKnowledgeDocument,+ arg.Column1,+ arg.Column2,+ arg.Column3,+ arg.Column4,+ )+ var i UpdateKnowledgeDocumentRow+ err := row.Scan(&i.ID, &i.Document, &i.Cmetadata)+ return i, err+}diff --git a/backend/pkg/database/knowledge/knowledge.go b/backend/pkg/database/knowledge/knowledge.gonew file mode 100644index 00000000..51fbcf97--- /dev/null+++ b/backend/pkg/database/knowledge/knowledge.go@@ -0,0 +1,643 @@+package knowledge++import (+ "context"+ "database/sql"+ "encoding/json"+ "fmt"+ "slices"+ "strconv"+ "strings"++ "pentagi/pkg/database"+ "pentagi/pkg/graph/model"+ "pentagi/pkg/graph/subscriptions"+ "pentagi/pkg/providers/embeddings"++ "github.com/sqlc-dev/pqtype"+ "github.com/vxcontrol/langchaingo/schema"+ "github.com/vxcontrol/langchaingo/vectorstores"+)++const (+ collectionName = "langchain"+ defaultSearchLimit = 10+ defaultSearchThreshold = float32(0.2)+ manualDocumentFlag = "manual"+)++// PublisherFactory creates a per-user KnowledgePublisher.+// Matches subscriptions.SubscriptionsController.NewKnowledgePublisher signature.+type PublisherFactory func(userID int64) subscriptions.KnowledgePublisher++// KnowledgeStore covers all GraphQL knowledge operations:+// - Admin read methods have no user_id filtering.+// - User-scoped read methods filter cmetadata by user_id.+// - Write methods always record the caller's userID for event scoping and+// are added to cmetadata; user-scoped delete/update also enforce ownership.+type KnowledgeStore interface {+ // Admin reads+ ListDocuments(ctx context.Context, filter *model.KnowledgeFilter, withContent bool) ([]*model.KnowledgeDocument, error)+ GetDocument(ctx context.Context, id string) (*model.KnowledgeDocument, error)+ SearchDocuments(ctx context.Context, query string, filter *model.KnowledgeFilter, limit int) ([]*model.KnowledgeDocumentWithScore, error)++ // User-scoped reads (filter by user_id in cmetadata)+ ListUserDocuments(ctx context.Context, userID int64, filter *model.KnowledgeFilter, withContent bool) ([]*model.KnowledgeDocument, error)+ GetUserDocument(ctx context.Context, userID int64, id string) (*model.KnowledgeDocument, error)+ SearchUserDocuments(ctx context.Context, userID int64, query string, filter *model.KnowledgeFilter, limit int) ([]*model.KnowledgeDocumentWithScore, error)++ // Writes+ CreateDocument(ctx context.Context, userID int64, input model.CreateKnowledgeDocumentInput) (*model.KnowledgeDocument, error)+ UpdateDocument(ctx context.Context, userID int64, id string, input model.UpdateKnowledgeDocumentInput) (*model.KnowledgeDocument, error)+ UpdateUserDocument(ctx context.Context, userID int64, id string, input model.UpdateKnowledgeDocumentInput) (*model.KnowledgeDocument, error)+ DeleteDocument(ctx context.Context, userID int64, id string) error+ DeleteUserDocument(ctx context.Context, userID int64, id string) error+}++type knowledgeStore struct {+ db database.Querier+ store vectorstores.VectorStore // may be nil when no embedder is configured+ embedder embeddings.Embedder // used for computing new embeddings on create/update+ newKnp PublisherFactory+}++// NewKnowledgeStore constructs a KnowledgeStore.+// - store and embedder may be nil when the embedding provider is not configured;+// in that case create/update/search return a descriptive error while+// list/get/delete still work.+// - newKnp is called with the acting user's ID on each write to create a+// correctly scoped event publisher.+func NewKnowledgeStore(+ db database.Querier,+ store vectorstores.VectorStore,+ embedder embeddings.Embedder,+ newKnp PublisherFactory,+) KnowledgeStore {+ return &knowledgeStore{+ db: db,+ store: store,+ embedder: embedder,+ newKnp: newKnp,+ }+}++// ---- cmetadata helpers -------------------------------------------------------++// knowledgeMeta mirrors the flat JSON stored in langchain_pg_embedding.cmetadata.+type knowledgeMeta struct {+ DocType string `json:"doc_type,omitempty"`+ UserID int64 `json:"user_id,omitempty"`+ FlowID *int64 `json:"flow_id,omitempty"`+ TaskID *int64 `json:"task_id,omitempty"`+ SubtaskID *int64 `json:"subtask_id,omitempty"`+ Question string `json:"question,omitempty"`+ Description string `json:"description,omitempty"`+ GuideType string `json:"guide_type,omitempty"`+ AnswerType string `json:"answer_type,omitempty"`+ CodeLang string `json:"code_lang,omitempty"`+ PartSize int `json:"part_size,omitempty"`+ TotalSize int `json:"total_size,omitempty"`+ Manual bool `json:"manual,omitempty"`+}++func parseMeta(raw string) knowledgeMeta {+ var m knowledgeMeta+ if raw != "" {+ _ = json.Unmarshal([]byte(raw), &m)+ }+ return m+}++func nullStr(ns sql.NullString) string {+ if ns.Valid {+ return ns.String+ }+ return "{}"+}++func nsOf(s string) sql.NullString {+ return sql.NullString{String: s, Valid: true}+}++// formatVector converts a float32 slice into the PostgreSQL vector literal '[f1,f2,...]'.+func formatVector(v []float32) string {+ strs := make([]string, len(v))+ for i, f := range v {+ strs[i] = strconv.FormatFloat(float64(f), 'f', -1, 32)+ }+ return "[" + strings.Join(strs, ",") + "]"+}++// metaToJSON serialises a knowledgeMeta into a pqtype.NullRawMessage for sqlc.+func metaToJSON(m knowledgeMeta) (pqtype.NullRawMessage, error) {+ b, err := json.Marshal(m)+ if err != nil {+ return pqtype.NullRawMessage{}, err+ }+ return pqtype.NullRawMessage{RawMessage: b, Valid: true}, nil+}++// rowToModel converts a sqlc knowledge row into a GraphQL model.+func rowToModel(id, document, cmetadataRaw string, withContent bool) *model.KnowledgeDocument {+ meta := parseMeta(cmetadataRaw)+ content := document+ if !withContent {+ content = ""+ }+ return metaToModelDoc(id, content, meta)+}++func metaToModelDoc(id, content string, meta knowledgeMeta) *model.KnowledgeDocument {+ doc := &model.KnowledgeDocument{+ ID: id,+ UserID: meta.UserID,+ Content: content,+ Question: meta.Question,+ PartSize: meta.PartSize,+ TotalSize: meta.TotalSize,+ Manual: meta.Manual,+ }++ switch meta.DocType {+ case "answer":+ doc.DocType = model.KnowledgeDocTypeAnswer+ case "guide":+ doc.DocType = model.KnowledgeDocTypeGuide+ case "code":+ doc.DocType = model.KnowledgeDocTypeCode+ default:+ doc.DocType = model.KnowledgeDocTypeAnswer+ }++ if meta.FlowID != nil {+ doc.FlowID = meta.FlowID+ }+ if meta.TaskID != nil {+ doc.TaskID = meta.TaskID+ }+ if meta.SubtaskID != nil {+ doc.SubtaskID = meta.SubtaskID+ }+ if meta.Description != "" {+ d := meta.Description+ doc.Description = &d+ }+ if meta.GuideType != "" {+ gt := model.KnowledgeGuideType(meta.GuideType)+ doc.GuideType = >+ }+ if meta.AnswerType != "" {+ at := model.KnowledgeAnswerType(meta.AnswerType)+ doc.AnswerType = &at+ }+ if meta.CodeLang != "" {+ cl := meta.CodeLang+ doc.CodeLang = &cl+ }+ return doc+}++// applyGoFilters applies optional filters that cannot be expressed as single SQL predicates.+func applyGoFilters(docs []*model.KnowledgeDocument, filter *model.KnowledgeFilter) []*model.KnowledgeDocument {+ if filter == nil {+ return docs+ }+ result := make([]*model.KnowledgeDocument, 0, len(docs))+ for _, doc := range docs {+ if len(filter.DocTypes) > 0 && !slices.Contains(filter.DocTypes, doc.DocType) {+ continue+ }+ if len(filter.GuideTypes) > 0 && (doc.GuideType == nil || !slices.Contains(filter.GuideTypes, *doc.GuideType)) {+ continue+ }+ if len(filter.AnswerTypes) > 0 && (doc.AnswerType == nil || !slices.Contains(filter.AnswerTypes, *doc.AnswerType)) {+ continue+ }+ if len(filter.CodeLangs) > 0 && (doc.CodeLang == nil || !slices.Contains(filter.CodeLangs, *doc.CodeLang)) {+ continue+ }+ if filter.Manual != nil && doc.Manual != *filter.Manual {+ continue+ }+ result = append(result, doc)+ }+ return result+}++// buildSearchFilters converts a KnowledgeFilter to a pgvector filter map.+// Only single-value equality filters are expressed here; arrays are applied in Go.+func buildSearchFilters(userID int64, filter *model.KnowledgeFilter) map[string]any {+ f := make(map[string]any)+ if userID > 0 {+ f["user_id"] = strconv.FormatInt(userID, 10)+ }+ if filter == nil {+ return f+ }+ if len(filter.DocTypes) == 1 {+ f["doc_type"] = string(filter.DocTypes[0])+ }+ if len(filter.GuideTypes) == 1 {+ f["guide_type"] = string(filter.GuideTypes[0])+ }+ if len(filter.AnswerTypes) == 1 {+ f["answer_type"] = string(filter.AnswerTypes[0])+ }+ if len(filter.CodeLangs) == 1 {+ f["code_lang"] = filter.CodeLangs[0]+ }+ if filter.FlowID != nil {+ f["flow_id"] = strconv.FormatInt(*filter.FlowID, 10)+ }+ return f+}++func (ks *knowledgeStore) requireStore() error {+ if ks.store == nil {+ return fmt.Errorf("knowledge: embedding provider is not configured")+ }+ return nil+}++func (ks *knowledgeStore) requireEmbedder() error {+ if ks.embedder == nil || !ks.embedder.IsAvailable() {+ return fmt.Errorf("knowledge: embedding provider is not available")+ }+ return nil+}++// ---- ListDocuments (admin) --------------------------------------------------++func (ks *knowledgeStore) ListDocuments(ctx context.Context, filter *model.KnowledgeFilter, withContent bool) ([]*model.KnowledgeDocument, error) {+ var docs []*model.KnowledgeDocument++ if filter != nil && filter.FlowID != nil {+ rows, err := ks.db.ListFlowKnowledgeDocuments(ctx, nsOf(strconv.FormatInt(*filter.FlowID, 10)))+ if err != nil {+ return nil, fmt.Errorf("knowledge: list by flow: %w", err)+ }+ for _, r := range rows {+ docs = append(docs, rowToModel(r.ID, r.Document, nullStr(r.Cmetadata), withContent))+ }+ } else {+ rows, err := ks.db.ListAllKnowledgeDocuments(ctx)+ if err != nil {+ return nil, fmt.Errorf("knowledge: list all: %w", err)+ }+ for _, r := range rows {+ docs = append(docs, rowToModel(r.ID, r.Document, nullStr(r.Cmetadata), withContent))+ }+ }++ return applyGoFilters(docs, filter), nil+}++// ---- ListUserDocuments (user-scoped) ----------------------------------------++func (ks *knowledgeStore) ListUserDocuments(ctx context.Context, userID int64, filter *model.KnowledgeFilter, withContent bool) ([]*model.KnowledgeDocument, error) {+ userIDStr := strconv.FormatInt(userID, 10)+ var docs []*model.KnowledgeDocument++ if filter != nil && filter.FlowID != nil {+ // Flow-scoped listing; user_id check applied in Go for safety.+ rows, err := ks.db.ListFlowKnowledgeDocuments(ctx, nsOf(strconv.FormatInt(*filter.FlowID, 10)))+ if err != nil {+ return nil, fmt.Errorf("knowledge: list by flow (user): %w", err)+ }+ for _, r := range rows {+ meta := parseMeta(nullStr(r.Cmetadata))+ if strconv.FormatInt(meta.UserID, 10) != userIDStr {+ continue+ }+ docs = append(docs, rowToModel(r.ID, r.Document, nullStr(r.Cmetadata), withContent))+ }+ } else {+ rows, err := ks.db.ListUserKnowledgeDocuments(ctx, nsOf(userIDStr))+ if err != nil {+ return nil, fmt.Errorf("knowledge: list user docs: %w", err)+ }+ for _, r := range rows {+ docs = append(docs, rowToModel(r.ID, r.Document, nullStr(r.Cmetadata), withContent))+ }+ }++ return applyGoFilters(docs, filter), nil+}++// ---- GetDocument (admin) ----------------------------------------------------++func (ks *knowledgeStore) GetDocument(ctx context.Context, id string) (*model.KnowledgeDocument, error) {+ row, err := ks.db.GetKnowledgeDocument(ctx, id)+ if err != nil {+ return nil, fmt.Errorf("knowledge: get document %s: %w", id, err)+ }+ return rowToModel(row.ID, row.Document, nullStr(row.Cmetadata), true), nil+}++// ---- GetUserDocument (user-scoped) ------------------------------------------++func (ks *knowledgeStore) GetUserDocument(ctx context.Context, userID int64, id string) (*model.KnowledgeDocument, error) {+ row, err := ks.db.GetUserKnowledgeDocument(ctx, database.GetUserKnowledgeDocumentParams{+ Uuid: id,+ Cmetadata: nsOf(strconv.FormatInt(userID, 10)),+ })+ if err != nil {+ return nil, fmt.Errorf("knowledge: get user document %s: %w", id, err)+ }+ return rowToModel(row.ID, row.Document, nullStr(row.Cmetadata), true), nil+}++// ---- SearchDocuments (admin) ------------------------------------------------++func (ks *knowledgeStore) SearchDocuments(ctx context.Context, query string, filter *model.KnowledgeFilter, limit int) ([]*model.KnowledgeDocumentWithScore, error) {+ return ks.doSearch(ctx, 0, query, filter, limit)+}++// ---- SearchUserDocuments (user-scoped) --------------------------------------++func (ks *knowledgeStore) SearchUserDocuments(ctx context.Context, userID int64, query string, filter *model.KnowledgeFilter, limit int) ([]*model.KnowledgeDocumentWithScore, error) {+ return ks.doSearch(ctx, userID, query, filter, limit)+}++func (ks *knowledgeStore) doSearch(ctx context.Context, userID int64, query string, filter *model.KnowledgeFilter, limit int) ([]*model.KnowledgeDocumentWithScore, error) {+ if err := ks.requireStore(); err != nil {+ return nil, err+ }+ if limit <= 0 {+ limit = defaultSearchLimit+ }++ pgFilters := buildSearchFilters(userID, filter)+ opts := []vectorstores.Option{+ vectorstores.WithScoreThreshold(defaultSearchThreshold),+ }+ if len(pgFilters) > 0 {+ opts = append(opts, vectorstores.WithFilters(pgFilters))+ }++ schemaDocs, err := ks.store.SimilaritySearch(ctx, query, limit, opts...)+ if err != nil {+ return nil, fmt.Errorf("knowledge: similarity search: %w", err)+ }++ results := make([]*model.KnowledgeDocumentWithScore, 0, len(schemaDocs))+ for _, sd := range schemaDocs {+ doc := schemaDocToModel(sd)+ if !passesGoFilter(doc, filter) {+ continue+ }+ results = append(results, &model.KnowledgeDocumentWithScore{+ Score: float64(sd.Score),+ Document: doc,+ })+ }+ return results, nil+}++func schemaDocToModel(sd schema.Document) *model.KnowledgeDocument {+ raw, _ := json.Marshal(sd.Metadata)+ meta := parseMeta(string(raw))+ return metaToModelDoc("", sd.PageContent, meta)+}++func passesGoFilter(doc *model.KnowledgeDocument, filter *model.KnowledgeFilter) bool {+ if filter == nil {+ return true+ }+ if len(filter.DocTypes) > 1 && !slices.Contains(filter.DocTypes, doc.DocType) {+ return false+ }+ if len(filter.GuideTypes) > 1 && (doc.GuideType == nil || !slices.Contains(filter.GuideTypes, *doc.GuideType)) {+ return false+ }+ if len(filter.AnswerTypes) > 1 && (doc.AnswerType == nil || !slices.Contains(filter.AnswerTypes, *doc.AnswerType)) {+ return false+ }+ if len(filter.CodeLangs) > 1 && (doc.CodeLang == nil || !slices.Contains(filter.CodeLangs, *doc.CodeLang)) {+ return false+ }+ if filter.Manual != nil && doc.Manual != *filter.Manual {+ return false+ }+ return true+}++// ---- CreateDocument ---------------------------------------------------------++func (ks *knowledgeStore) CreateDocument(ctx context.Context, userID int64, input model.CreateKnowledgeDocumentInput) (*model.KnowledgeDocument, error) {+ if err := ks.requireStore(); err != nil {+ return nil, err+ }++ meta := knowledgeMeta{+ DocType: string(input.DocType),+ UserID: userID,+ Question: input.Question,+ Manual: true,+ }+ if input.Description != nil {+ meta.Description = *input.Description+ }+ if input.GuideType != nil {+ meta.GuideType = string(*input.GuideType)+ }+ if input.AnswerType != nil {+ meta.AnswerType = string(*input.AnswerType)+ }+ if input.CodeLang != nil {+ meta.CodeLang = *input.CodeLang+ }++ content := strings.TrimSpace(input.Content)+ meta.PartSize = len(content)+ meta.TotalSize = len(content)++ metaMap := metaToMap(meta)+ ids, err := ks.store.AddDocuments(ctx, []schema.Document{{+ PageContent: content,+ Metadata: metaMap,+ }})+ if err != nil {+ return nil, fmt.Errorf("knowledge: create document: %w", err)+ }+ if len(ids) == 0 {+ return nil, fmt.Errorf("knowledge: create returned no IDs")+ }++ doc := metaToModelDoc(ids[0], content, meta)+ ks.newKnp(userID).KnowledgeDocumentCreated(ctx, doc)+ return doc, nil+}++// ---- UpdateDocument (admin) -------------------------------------------------++func (ks *knowledgeStore) UpdateDocument(ctx context.Context, userID int64, id string, input model.UpdateKnowledgeDocumentInput) (*model.KnowledgeDocument, error) {+ existing, err := ks.GetDocument(ctx, id)+ if err != nil {+ return nil, err+ }+ return ks.doUpdate(ctx, userID, id, existing, input)+}++// ---- UpdateUserDocument (user-scoped) ---------------------------------------++func (ks *knowledgeStore) UpdateUserDocument(ctx context.Context, userID int64, id string, input model.UpdateKnowledgeDocumentInput) (*model.KnowledgeDocument, error) {+ existing, err := ks.GetUserDocument(ctx, userID, id)+ if err != nil {+ return nil, err+ }+ return ks.doUpdate(ctx, userID, id, existing, input)+}++func (ks *knowledgeStore) doUpdate(ctx context.Context, userID int64, id string, existing *model.KnowledgeDocument, input model.UpdateKnowledgeDocumentInput) (*model.KnowledgeDocument, error) {+ if err := ks.requireEmbedder(); err != nil {+ return nil, err+ }++ // Build updated metadata from existing document.+ // Preserve the original owner (UserID) — the caller's identity (userID) is+ // used only for event scoping via the publisher, not stored in cmetadata.+ meta := knowledgeMeta{+ DocType: string(existing.DocType),+ UserID: existing.UserID,+ Manual: existing.Manual,+ Question: existing.Question,+ }+ if existing.FlowID != nil {+ meta.FlowID = existing.FlowID+ }+ if existing.TaskID != nil {+ meta.TaskID = existing.TaskID+ }+ if existing.SubtaskID != nil {+ meta.SubtaskID = existing.SubtaskID+ }+ if existing.Description != nil {+ meta.Description = *existing.Description+ }+ if existing.GuideType != nil {+ meta.GuideType = string(*existing.GuideType)+ }+ if existing.AnswerType != nil {+ meta.AnswerType = string(*existing.AnswerType)+ }+ if existing.CodeLang != nil {+ meta.CodeLang = *existing.CodeLang+ }++ // Apply input fields.+ content := strings.TrimSpace(input.Content)+ if input.Question != nil {+ meta.Question = *input.Question+ }+ if input.Description != nil {+ meta.Description = *input.Description+ }+ if input.GuideType != nil {+ meta.GuideType = string(*input.GuideType)+ }+ if input.AnswerType != nil {+ meta.AnswerType = string(*input.AnswerType)+ }+ if input.CodeLang != nil {+ meta.CodeLang = *input.CodeLang+ }+ meta.PartSize = len(content)+ meta.TotalSize = len(content)++ // Compute new embedding.+ vecs, err := ks.embedder.EmbedDocuments(ctx, []string{content})+ if err != nil {+ return nil, fmt.Errorf("knowledge: compute embedding: %w", err)+ }+ if len(vecs) == 0 {+ return nil, fmt.Errorf("knowledge: embedder returned no vectors")+ }++ cmJSON, err := metaToJSON(meta)+ if err != nil {+ return nil, fmt.Errorf("knowledge: marshal cmetadata: %w", err)+ }++ row, err := ks.db.UpdateKnowledgeDocument(ctx, database.UpdateKnowledgeDocumentParams{+ Column1: nsOf(id), // uuid::text = $1+ Column2: formatVector(vecs[0]), // embedding = $2::vector+ Column3: nsOf(content), // document = $3+ Column4: cmJSON, // cmetadata = $4::json+ })+ if err != nil {+ return nil, fmt.Errorf("knowledge: update document %s: %w", id, err)+ }++ doc := rowToModel(row.ID, row.Document, nullStr(row.Cmetadata), true)+ ks.newKnp(userID).KnowledgeDocumentUpdated(ctx, doc)+ return doc, nil+}++// ---- DeleteDocument (admin) -------------------------------------------------++func (ks *knowledgeStore) DeleteDocument(ctx context.Context, userID int64, id string) error {+ doc, err := ks.GetDocument(ctx, id)+ if err != nil {+ return err+ }+ if err := ks.db.DeleteKnowledgeDocument(ctx, nsOf(id)); err != nil {+ return fmt.Errorf("knowledge: delete document %s: %w", id, err)+ }+ ks.newKnp(userID).KnowledgeDocumentDeleted(ctx, doc)+ return nil+}++// ---- DeleteUserDocument (user-scoped) ---------------------------------------++func (ks *knowledgeStore) DeleteUserDocument(ctx context.Context, userID int64, id string) error {+ doc, err := ks.GetUserDocument(ctx, userID, id)+ if err != nil {+ return err+ }+ if err := ks.db.DeleteUserKnowledgeDocument(ctx, database.DeleteUserKnowledgeDocumentParams{+ Column1: nsOf(id),+ Column2: nsOf(strconv.FormatInt(userID, 10)),+ }); err != nil {+ return fmt.Errorf("knowledge: delete user document %s: %w", id, err)+ }+ ks.newKnp(userID).KnowledgeDocumentDeleted(ctx, doc)+ return nil+}++// ---- helpers ----------------------------------------------------------------++// metaToMap converts knowledgeMeta to the map[string]any format used by+// langchaingo's schema.Document.Metadata / pgvector cmetadata.+func metaToMap(m knowledgeMeta) map[string]any {+ mp := map[string]any{+ "doc_type": m.DocType,+ "user_id": m.UserID,+ "question": m.Question,+ "part_size": m.PartSize,+ "total_size": m.TotalSize,+ manualDocumentFlag: m.Manual,+ }+ if m.Description != "" {+ mp["description"] = m.Description+ }+ if m.GuideType != "" {+ mp["guide_type"] = m.GuideType+ }+ if m.AnswerType != "" {+ mp["answer_type"] = m.AnswerType+ }+ if m.CodeLang != "" {+ mp["code_lang"] = m.CodeLang+ }+ if m.FlowID != nil {+ mp["flow_id"] = *m.FlowID+ }+ if m.TaskID != nil {+ mp["task_id"] = *m.TaskID+ }+ if m.SubtaskID != nil {+ mp["subtask_id"] = *m.SubtaskID+ }+ return mp+}diff --git a/backend/pkg/database/knowledge/knowledge_test.go b/backend/pkg/database/knowledge/knowledge_test.gonew file mode 100644index 00000000..feffdac7--- /dev/null+++ b/backend/pkg/database/knowledge/knowledge_test.go@@ -0,0 +1,1470 @@+package knowledge++import (+ "context"+ "database/sql"+ "errors"+ "fmt"+ "testing"++ "pentagi/pkg/database"+ "pentagi/pkg/graph/model"+ "pentagi/pkg/graph/subscriptions"++ "github.com/vxcontrol/langchaingo/schema"+ "github.com/vxcontrol/langchaingo/vectorstores"+)++// ============================================================================+// Mocks+// ============================================================================++// --- mockDB -----------------------------------------------------------------++// mockDB embeds database.Querier (nil) so the compiler sees a full+// implementation. Only knowledge-related methods are overridden; any accidental+// call to another method will panic at runtime (acceptable in unit tests).+type mockDB struct {+ database.Querier // nil — panics if an unexpected method is called++ getKnowledge func(ctx context.Context, uuid string) (database.GetKnowledgeDocumentRow, error)+ getUserKnowledge func(ctx context.Context, arg database.GetUserKnowledgeDocumentParams) (database.GetUserKnowledgeDocumentRow, error)+ listAll func(ctx context.Context) ([]database.ListAllKnowledgeDocumentsRow, error)+ listFlow func(ctx context.Context, flowID sql.NullString) ([]database.ListFlowKnowledgeDocumentsRow, error)+ listUser func(ctx context.Context, userID sql.NullString) ([]database.ListUserKnowledgeDocumentsRow, error)+ updateKnowledge func(ctx context.Context, arg database.UpdateKnowledgeDocumentParams) (database.UpdateKnowledgeDocumentRow, error)+ deleteKnowledge func(ctx context.Context, dollar_1 sql.NullString) error+ deleteUserKnowledge func(ctx context.Context, arg database.DeleteUserKnowledgeDocumentParams) error+}++func (m *mockDB) GetKnowledgeDocument(ctx context.Context, uuid string) (database.GetKnowledgeDocumentRow, error) {+ return m.getKnowledge(ctx, uuid)+}+func (m *mockDB) GetUserKnowledgeDocument(ctx context.Context, arg database.GetUserKnowledgeDocumentParams) (database.GetUserKnowledgeDocumentRow, error) {+ return m.getUserKnowledge(ctx, arg)+}+func (m *mockDB) ListAllKnowledgeDocuments(ctx context.Context) ([]database.ListAllKnowledgeDocumentsRow, error) {+ return m.listAll(ctx)+}+func (m *mockDB) ListFlowKnowledgeDocuments(ctx context.Context, cmetadata sql.NullString) ([]database.ListFlowKnowledgeDocumentsRow, error) {+ return m.listFlow(ctx, cmetadata)+}+func (m *mockDB) ListUserKnowledgeDocuments(ctx context.Context, cmetadata sql.NullString) ([]database.ListUserKnowledgeDocumentsRow, error) {+ return m.listUser(ctx, cmetadata)+}+func (m *mockDB) UpdateKnowledgeDocument(ctx context.Context, arg database.UpdateKnowledgeDocumentParams) (database.UpdateKnowledgeDocumentRow, error) {+ return m.updateKnowledge(ctx, arg)+}+func (m *mockDB) DeleteKnowledgeDocument(ctx context.Context, dollar_1 sql.NullString) error {+ return m.deleteKnowledge(ctx, dollar_1)+}+func (m *mockDB) DeleteUserKnowledgeDocument(ctx context.Context, arg database.DeleteUserKnowledgeDocumentParams) error {+ return m.deleteUserKnowledge(ctx, arg)+}++// --- mockVectorStore --------------------------------------------------------++type mockVectorStore struct {+ similaritySearchFn func(ctx context.Context, query string, numDocuments int, options ...vectorstores.Option) ([]schema.Document, error)+ addDocumentsFn func(ctx context.Context, docs []schema.Document, options ...vectorstores.Option) ([]string, error)+}++func (m *mockVectorStore) SimilaritySearch(ctx context.Context, query string, numDocuments int, options ...vectorstores.Option) ([]schema.Document, error) {+ return m.similaritySearchFn(ctx, query, numDocuments, options...)+}+func (m *mockVectorStore) AddDocuments(ctx context.Context, docs []schema.Document, options ...vectorstores.Option) ([]string, error) {+ return m.addDocumentsFn(ctx, docs, options...)+}++// --- mockEmbedder -----------------------------------------------------------++type mockEmbedder struct {+ available bool+ embedDocumentsFn func(ctx context.Context, texts []string) ([][]float32, error)+ embedQueryFn func(ctx context.Context, text string) ([]float32, error)+}++func (m *mockEmbedder) IsAvailable() bool { return m.available }+func (m *mockEmbedder) EmbedDocuments(ctx context.Context, texts []string) ([][]float32, error) {+ if m.embedDocumentsFn != nil {+ return m.embedDocumentsFn(ctx, texts)+ }+ return [][]float32{{0.1, 0.2, 0.3}}, nil+}+func (m *mockEmbedder) EmbedQuery(ctx context.Context, text string) ([]float32, error) {+ if m.embedQueryFn != nil {+ return m.embedQueryFn(ctx, text)+ }+ return []float32{0.1, 0.2, 0.3}, nil+}++// --- mockPublisher ----------------------------------------------------------++type mockPublisher struct {+ createdDocs []*model.KnowledgeDocument+ updatedDocs []*model.KnowledgeDocument+ deletedDocs []*model.KnowledgeDocument+ userID int64+}++func (m *mockPublisher) GetUserID() int64 { return m.userID }+func (m *mockPublisher) SetUserID(id int64) { m.userID = id }+func (m *mockPublisher) KnowledgeDocumentCreated(_ context.Context, doc *model.KnowledgeDocument) {+ m.createdDocs = append(m.createdDocs, doc)+}+func (m *mockPublisher) KnowledgeDocumentUpdated(_ context.Context, doc *model.KnowledgeDocument) {+ m.updatedDocs = append(m.updatedDocs, doc)+}+func (m *mockPublisher) KnowledgeDocumentDeleted(_ context.Context, doc *model.KnowledgeDocument) {+ m.deletedDocs = append(m.deletedDocs, doc)+}++// ============================================================================+// Helpers+// ============================================================================++func ptr[T any](v T) *T { return &v }++// makeRow builds a synthetic knowledge row used across multiple tests.+func makeRow(id, document, cmetadata string) database.GetKnowledgeDocumentRow {+ return database.GetKnowledgeDocumentRow{+ ID: id,+ Document: document,+ Cmetadata: sql.NullString{String: cmetadata, Valid: true},+ }+}++func makeListAllRow(id, document, cmetadata string) database.ListAllKnowledgeDocumentsRow {+ return database.ListAllKnowledgeDocumentsRow{+ ID: id,+ Document: document,+ Cmetadata: sql.NullString{String: cmetadata, Valid: true},+ }+}++func makeListFlowRow(id, document, cmetadata string) database.ListFlowKnowledgeDocumentsRow {+ return database.ListFlowKnowledgeDocumentsRow{+ ID: id,+ Document: document,+ Cmetadata: sql.NullString{String: cmetadata, Valid: true},+ }+}++func makeListUserRow(id, document, cmetadata string) database.ListUserKnowledgeDocumentsRow {+ return database.ListUserKnowledgeDocumentsRow{+ ID: id,+ Document: document,+ Cmetadata: sql.NullString{String: cmetadata, Valid: true},+ }+}++// newPublisherFactory returns a PublisherFactory backed by a single shared publisher.+func newPublisherFactory(pub *mockPublisher) PublisherFactory {+ return func(userID int64) subscriptions.KnowledgePublisher {+ pub.userID = userID+ return pub+ }+}++// ============================================================================+// Tests: pure helper functions+// ============================================================================++func TestParseMeta(t *testing.T) {+ t.Run("empty string returns zero value", func(t *testing.T) {+ m := parseMeta("")+ if m.DocType != "" || m.UserID != 0 || m.Question != "" {+ t.Fatal("expected zero-value meta for empty input")+ }+ })++ t.Run("valid JSON parses all fields including user_id", func(t *testing.T) {+ raw := `{"doc_type":"guide","user_id":42,"flow_id":7,"question":"q","guide_type":"pentest","manual":true,"part_size":100,"total_size":200}`+ m := parseMeta(raw)+ if m.DocType != "guide" {+ t.Fatalf("DocType: want guide, got %s", m.DocType)+ }+ if m.UserID != 42 {+ t.Fatalf("UserID: want 42, got %d", m.UserID)+ }+ if m.FlowID == nil || *m.FlowID != 7 {+ t.Fatal("FlowID mismatch")+ }+ if m.Question != "q" {+ t.Fatal("Question mismatch")+ }+ if m.GuideType != "pentest" {+ t.Fatal("GuideType mismatch")+ }+ if !m.Manual {+ t.Fatal("Manual should be true")+ }+ if m.PartSize != 100 || m.TotalSize != 200 {+ t.Fatal("sizes mismatch")+ }+ })++ t.Run("invalid JSON returns zero value without panic", func(t *testing.T) {+ m := parseMeta("not-json")+ if m.DocType != "" {+ t.Fatal("expected empty DocType for invalid JSON")+ }+ })++ t.Run("partial JSON fills only present fields", func(t *testing.T) {+ m := parseMeta(`{"doc_type":"code","code_lang":"python"}`)+ if m.DocType != "code" || m.CodeLang != "python" {+ t.Fatal("partial JSON mismatch")+ }+ if m.UserID != 0 {+ t.Fatal("UserID should be zero")+ }+ })+}++func TestNullStr(t *testing.T) {+ t.Run("valid NullString returns inner string", func(t *testing.T) {+ ns := sql.NullString{String: "hello", Valid: true}+ if got := nullStr(ns); got != "hello" {+ t.Fatalf("want hello, got %s", got)+ }+ })++ t.Run("invalid NullString returns empty JSON object", func(t *testing.T) {+ ns := sql.NullString{}+ if got := nullStr(ns); got != "{}" {+ t.Fatalf("want {}, got %s", got)+ }+ })+}++func TestNsOf(t *testing.T) {+ ns := nsOf("test")+ if !ns.Valid || ns.String != "test" {+ t.Fatal("nsOf must return valid NullString with given value")+ }+}++func TestFormatVector(t *testing.T) {+ cases := []struct {+ name string+ input []float32+ want string+ }{+ {"empty", []float32{}, "[]"},+ {"single", []float32{1.0}, "[1]"},+ {"multiple", []float32{1.0, 2.0, 3.0}, "[1,2,3]"},+ {"precision", []float32{0.5}, "[0.5]"},+ }+ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ got := formatVector(tc.input)+ if got != tc.want {+ t.Fatalf("want %q, got %q", tc.want, got)+ }+ })+ }+}++func TestMetaToJSON(t *testing.T) {+ t.Run("serialises correctly", func(t *testing.T) {+ m := knowledgeMeta{DocType: "answer", UserID: 5, Question: "test?"}+ nm, err := metaToJSON(m)+ if err != nil {+ t.Fatal(err)+ }+ if !nm.Valid {+ t.Fatal("expected valid NullRawMessage")+ }+ parsed := parseMeta(string(nm.RawMessage))+ if parsed.DocType != "answer" || parsed.UserID != 5 || parsed.Question != "test?" {+ t.Fatal("round-trip mismatch")+ }+ })+}++func TestMetaToModelDoc(t *testing.T) {+ t.Run("doc_type answer", func(t *testing.T) {+ doc := metaToModelDoc("uuid1", "content", knowledgeMeta{DocType: "answer"})+ if doc.DocType != model.KnowledgeDocTypeAnswer {+ t.Fatal("wrong doc type")+ }+ if doc.ID != "uuid1" || doc.Content != "content" {+ t.Fatal("id/content mismatch")+ }+ })++ t.Run("doc_type guide", func(t *testing.T) {+ doc := metaToModelDoc("", "", knowledgeMeta{DocType: "guide"})+ if doc.DocType != model.KnowledgeDocTypeGuide {+ t.Fatal("wrong doc type")+ }+ })++ t.Run("doc_type code", func(t *testing.T) {+ doc := metaToModelDoc("", "", knowledgeMeta{DocType: "code"})+ if doc.DocType != model.KnowledgeDocTypeCode {+ t.Fatal("wrong doc type")+ }+ })++ t.Run("unknown doc_type defaults to answer", func(t *testing.T) {+ doc := metaToModelDoc("", "", knowledgeMeta{DocType: "memory"})+ if doc.DocType != model.KnowledgeDocTypeAnswer {+ t.Fatal("expected answer fallback")+ }+ })++ t.Run("optional guide fields", func(t *testing.T) {+ gt := "pentest"+ doc := metaToModelDoc("", "", knowledgeMeta{+ DocType: "guide",+ GuideType: gt,+ Description: "desc",+ })+ if doc.GuideType == nil || string(*doc.GuideType) != gt {+ t.Fatal("GuideType mismatch")+ }+ if doc.Description == nil || *doc.Description != "desc" {+ t.Fatal("Description mismatch")+ }+ })++ t.Run("optional answer fields", func(t *testing.T) {+ doc := metaToModelDoc("", "", knowledgeMeta{DocType: "answer", AnswerType: "vulnerability"})+ if doc.AnswerType == nil || string(*doc.AnswerType) != "vulnerability" {+ t.Fatal("AnswerType mismatch")+ }+ })++ t.Run("optional code fields", func(t *testing.T) {+ doc := metaToModelDoc("", "", knowledgeMeta{DocType: "code", CodeLang: "python"})+ if doc.CodeLang == nil || *doc.CodeLang != "python" {+ t.Fatal("CodeLang mismatch")+ }+ })++ t.Run("flow/task/subtask IDs", func(t *testing.T) {+ fid, tid, sid := int64(1), int64(2), int64(3)+ doc := metaToModelDoc("", "", knowledgeMeta{+ FlowID: &fid, TaskID: &tid, SubtaskID: &sid,+ })+ if doc.FlowID == nil || *doc.FlowID != 1 {+ t.Fatal("FlowID mismatch")+ }+ if doc.TaskID == nil || *doc.TaskID != 2 {+ t.Fatal("TaskID mismatch")+ }+ if doc.SubtaskID == nil || *doc.SubtaskID != 3 {+ t.Fatal("SubtaskID mismatch")+ }+ })++ t.Run("sizes and manual flag", func(t *testing.T) {+ doc := metaToModelDoc("", "", knowledgeMeta{PartSize: 50, TotalSize: 100, Manual: true})+ if doc.PartSize != 50 || doc.TotalSize != 100 || !doc.Manual {+ t.Fatal("sizes/manual mismatch")+ }+ })++ t.Run("user_id propagated to model", func(t *testing.T) {+ doc := metaToModelDoc("", "", knowledgeMeta{UserID: 77})+ if doc.UserID != 77 {+ t.Fatalf("UserID: want 77, got %d", doc.UserID)+ }+ })++ t.Run("zero user_id stays zero in model", func(t *testing.T) {+ doc := metaToModelDoc("", "", knowledgeMeta{})+ if doc.UserID != 0 {+ t.Fatalf("UserID: want 0, got %d", doc.UserID)+ }+ })+}++func TestRowToModel(t *testing.T) {+ cmetaJSON := `{"doc_type":"guide","question":"how?","part_size":10,"total_size":20}`++ t.Run("withContent=true includes document text", func(t *testing.T) {+ doc := rowToModel("id1", "text content", cmetaJSON, true)+ if doc.Content != "text content" {+ t.Fatal("expected content to be included")+ }+ })++ t.Run("withContent=false blanks document text", func(t *testing.T) {+ doc := rowToModel("id1", "text content", cmetaJSON, false)+ if doc.Content != "" {+ t.Fatalf("expected empty content, got %q", doc.Content)+ }+ })++ t.Run("cmetadata parsed into model fields", func(t *testing.T) {+ doc := rowToModel("id2", "", cmetaJSON, true)+ if doc.DocType != model.KnowledgeDocTypeGuide {+ t.Fatal("DocType mismatch")+ }+ if doc.Question != "how?" {+ t.Fatal("Question mismatch")+ }+ if doc.PartSize != 10 || doc.TotalSize != 20 {+ t.Fatal("sizes mismatch")+ }+ })++ t.Run("empty cmetadata yields defaults", func(t *testing.T) {+ doc := rowToModel("id3", "x", "{}", true)+ if doc.DocType != model.KnowledgeDocTypeAnswer {+ t.Fatal("expected default answer type")+ }+ if doc.GuideType != nil || doc.AnswerType != nil || doc.CodeLang != nil {+ t.Fatal("optional fields should be nil for empty meta")+ }+ })+}++// ============================================================================+// Tests: applyGoFilters+// ============================================================================++func TestApplyGoFilters(t *testing.T) {+ guide := &model.KnowledgeDocument{DocType: model.KnowledgeDocTypeGuide, GuideType: ptr(model.KnowledgeGuideTypePentest)}+ answer := &model.KnowledgeDocument{DocType: model.KnowledgeDocTypeAnswer, AnswerType: ptr(model.KnowledgeAnswerTypeVulnerability)}+ code := &model.KnowledgeDocument{DocType: model.KnowledgeDocTypeCode, CodeLang: ptr("python")}+ manualDoc := &model.KnowledgeDocument{DocType: model.KnowledgeDocTypeAnswer, Manual: true}++ all := []*model.KnowledgeDocument{guide, answer, code, manualDoc}++ t.Run("nil filter returns all", func(t *testing.T) {+ got := applyGoFilters(all, nil)+ if len(got) != 4 {+ t.Fatalf("want 4, got %d", len(got))+ }+ })++ t.Run("empty filter returns all", func(t *testing.T) {+ got := applyGoFilters(all, &model.KnowledgeFilter{})+ if len(got) != 4 {+ t.Fatalf("want 4, got %d", len(got))+ }+ })++ t.Run("single docType filter", func(t *testing.T) {+ got := applyGoFilters(all, &model.KnowledgeFilter{DocTypes: []model.KnowledgeDocType{model.KnowledgeDocTypeGuide}})+ if len(got) != 1 || got[0] != guide {+ t.Fatal("expected only guide")+ }+ })++ t.Run("multiple docType filter", func(t *testing.T) {+ got := applyGoFilters(all, &model.KnowledgeFilter{DocTypes: []model.KnowledgeDocType{model.KnowledgeDocTypeGuide, model.KnowledgeDocTypeCode}})+ if len(got) != 2 {+ t.Fatalf("want 2, got %d", len(got))+ }+ })++ t.Run("guideType filter excludes non-matching guide", func(t *testing.T) {+ otherGuide := &model.KnowledgeDocument{DocType: model.KnowledgeDocTypeGuide, GuideType: ptr(model.KnowledgeGuideTypeInstall)}+ got := applyGoFilters([]*model.KnowledgeDocument{guide, otherGuide}, &model.KnowledgeFilter{+ GuideTypes: []model.KnowledgeGuideType{model.KnowledgeGuideTypePentest},+ })+ if len(got) != 1 || got[0] != guide {+ t.Fatal("expected only pentest guide")+ }+ })++ t.Run("guideType filter excludes docs without guideType", func(t *testing.T) {+ got := applyGoFilters([]*model.KnowledgeDocument{answer, guide}, &model.KnowledgeFilter{+ GuideTypes: []model.KnowledgeGuideType{model.KnowledgeGuideTypePentest},+ })+ if len(got) != 1 || got[0] != guide {+ t.Fatal("answer without guideType must be excluded")+ }+ })++ t.Run("answerType filter", func(t *testing.T) {+ got := applyGoFilters(all, &model.KnowledgeFilter{+ AnswerTypes: []model.KnowledgeAnswerType{model.KnowledgeAnswerTypeVulnerability},+ })+ if len(got) != 1 || got[0] != answer {+ t.Fatal("expected only vulnerability answer")+ }+ })++ t.Run("codeLangs filter", func(t *testing.T) {+ got := applyGoFilters(all, &model.KnowledgeFilter{CodeLangs: []string{"python"}})+ if len(got) != 1 || got[0] != code {+ t.Fatal("expected only python code")+ }+ })++ t.Run("manual=true filter", func(t *testing.T) {+ got := applyGoFilters(all, &model.KnowledgeFilter{Manual: ptr(true)})+ if len(got) != 1 || got[0] != manualDoc {+ t.Fatal("expected only manual doc")+ }+ })++ t.Run("manual=false filter excludes manual docs", func(t *testing.T) {+ got := applyGoFilters(all, &model.KnowledgeFilter{Manual: ptr(false)})+ if len(got) != 3 {+ t.Fatalf("want 3 non-manual docs, got %d", len(got))+ }+ })++ t.Run("combined filters", func(t *testing.T) {+ got := applyGoFilters(all, &model.KnowledgeFilter{+ DocTypes: []model.KnowledgeDocType{model.KnowledgeDocTypeAnswer},+ Manual: ptr(false),+ })+ if len(got) != 1 || got[0] != answer {+ t.Fatal("expected only non-manual answer")+ }+ })++ t.Run("no match returns empty slice", func(t *testing.T) {+ got := applyGoFilters(all, &model.KnowledgeFilter{CodeLangs: []string{"rust"}})+ if len(got) != 0 {+ t.Fatal("expected empty result")+ }+ })+}++// ============================================================================+// Tests: buildSearchFilters+// ============================================================================++func TestBuildSearchFilters(t *testing.T) {+ t.Run("userID=0 produces no user_id key", func(t *testing.T) {+ f := buildSearchFilters(0, nil)+ if _, ok := f["user_id"]; ok {+ t.Fatal("user_id should be absent when userID=0")+ }+ })++ t.Run("userID>0 adds user_id string", func(t *testing.T) {+ f := buildSearchFilters(42, nil)+ if f["user_id"] != "42" {+ t.Fatalf("expected user_id=42, got %v", f["user_id"])+ }+ })++ t.Run("nil filter returns only userID-based key", func(t *testing.T) {+ f := buildSearchFilters(1, nil)+ if len(f) != 1 {+ t.Fatalf("want 1 key, got %d", len(f))+ }+ })++ t.Run("single docType sets doc_type", func(t *testing.T) {+ f := buildSearchFilters(0, &model.KnowledgeFilter{DocTypes: []model.KnowledgeDocType{model.KnowledgeDocTypeGuide}})+ if f["doc_type"] != "guide" {+ t.Fatalf("expected doc_type=guide, got %v", f["doc_type"])+ }+ })++ t.Run("multiple docTypes does NOT set doc_type (handled in Go)", func(t *testing.T) {+ f := buildSearchFilters(0, &model.KnowledgeFilter{+ DocTypes: []model.KnowledgeDocType{model.KnowledgeDocTypeGuide, model.KnowledgeDocTypeCode},+ })+ if _, ok := f["doc_type"]; ok {+ t.Fatal("doc_type should not be set for multiple types")+ }+ })++ t.Run("single guideType sets guide_type", func(t *testing.T) {+ f := buildSearchFilters(0, &model.KnowledgeFilter{GuideTypes: []model.KnowledgeGuideType{model.KnowledgeGuideTypePentest}})+ if f["guide_type"] != "pentest" {+ t.Fatalf("expected guide_type=pentest, got %v", f["guide_type"])+ }+ })++ t.Run("single answerType sets answer_type", func(t *testing.T) {+ f := buildSearchFilters(0, &model.KnowledgeFilter{AnswerTypes: []model.KnowledgeAnswerType{model.KnowledgeAnswerTypeCode}})+ if f["answer_type"] != "code" {+ t.Fatalf("expected answer_type=code, got %v", f["answer_type"])+ }+ })++ t.Run("single codeLang sets code_lang", func(t *testing.T) {+ f := buildSearchFilters(0, &model.KnowledgeFilter{CodeLangs: []string{"go"}})+ if f["code_lang"] != "go" {+ t.Fatalf("expected code_lang=go, got %v", f["code_lang"])+ }+ })++ t.Run("flowID sets flow_id", func(t *testing.T) {+ f := buildSearchFilters(0, &model.KnowledgeFilter{FlowID: ptr(int64(55))})+ if f["flow_id"] != "55" {+ t.Fatalf("expected flow_id=55, got %v", f["flow_id"])+ }+ })++ t.Run("userID and all single filters combined", func(t *testing.T) {+ f := buildSearchFilters(7, &model.KnowledgeFilter{+ DocTypes: []model.KnowledgeDocType{model.KnowledgeDocTypeAnswer},+ AnswerTypes: []model.KnowledgeAnswerType{model.KnowledgeAnswerTypeGuide},+ FlowID: ptr(int64(3)),+ })+ if f["user_id"] != "7" || f["doc_type"] != "answer" || f["answer_type"] != "guide" || f["flow_id"] != "3" {+ t.Fatalf("combined filters mismatch: %v", f)+ }+ })+}++// ============================================================================+// Tests: ListDocuments / ListUserDocuments+// ============================================================================++func TestListDocuments(t *testing.T) {+ ctx := context.Background()++ t.Run("no filter calls ListAll", func(t *testing.T) {+ called := false+ db := &mockDB{+ listAll: func(_ context.Context) ([]database.ListAllKnowledgeDocumentsRow, error) {+ called = true+ return []database.ListAllKnowledgeDocumentsRow{+ makeListAllRow("u1", "text", `{"doc_type":"answer"}`),+ }, nil+ },+ }+ ks := &knowledgeStore{db: db}+ docs, err := ks.ListDocuments(ctx, nil, true)+ if err != nil {+ t.Fatal(err)+ }+ if !called {+ t.Fatal("ListAllKnowledgeDocuments was not called")+ }+ if len(docs) != 1 || docs[0].ID != "u1" {+ t.Fatal("unexpected result")+ }+ })++ t.Run("flowID filter calls ListFlow with correct id", func(t *testing.T) {+ var gotFlowID string+ db := &mockDB{+ listFlow: func(_ context.Context, flowID sql.NullString) ([]database.ListFlowKnowledgeDocumentsRow, error) {+ gotFlowID = flowID.String+ return nil, nil+ },+ }+ ks := &knowledgeStore{db: db}+ _, err := ks.ListDocuments(ctx, &model.KnowledgeFilter{FlowID: ptr(int64(99))}, true)+ if err != nil {+ t.Fatal(err)+ }+ if gotFlowID != "99" {+ t.Fatalf("expected flow_id=99, got %q", gotFlowID)+ }+ })++ t.Run("withContent=false blanks document text", func(t *testing.T) {+ db := &mockDB{+ listAll: func(_ context.Context) ([]database.ListAllKnowledgeDocumentsRow, error) {+ return []database.ListAllKnowledgeDocumentsRow{+ makeListAllRow("u1", "secret text", `{"doc_type":"answer"}`),+ }, nil+ },+ }+ ks := &knowledgeStore{db: db}+ docs, err := ks.ListDocuments(ctx, nil, false)+ if err != nil || docs[0].Content != "" {+ t.Fatal("content should be empty when withContent=false")+ }+ })++ t.Run("db error is wrapped and returned", func(t *testing.T) {+ db := &mockDB{+ listAll: func(_ context.Context) ([]database.ListAllKnowledgeDocumentsRow, error) {+ return nil, errors.New("db gone")+ },+ }+ ks := &knowledgeStore{db: db}+ _, err := ks.ListDocuments(ctx, nil, true)+ if err == nil || !errors.Is(err, fmt.Errorf("knowledge: list all: %w", errors.New("db gone"))) {+ if err == nil {+ t.Fatal("expected error")+ }+ }+ })++ t.Run("go filters applied after db fetch", func(t *testing.T) {+ db := &mockDB{+ listAll: func(_ context.Context) ([]database.ListAllKnowledgeDocumentsRow, error) {+ return []database.ListAllKnowledgeDocumentsRow{+ makeListAllRow("g1", "", `{"doc_type":"guide"}`),+ makeListAllRow("a1", "", `{"doc_type":"answer"}`),+ }, nil+ },+ }+ ks := &knowledgeStore{db: db}+ docs, err := ks.ListDocuments(ctx, &model.KnowledgeFilter{DocTypes: []model.KnowledgeDocType{model.KnowledgeDocTypeGuide}}, false)+ if err != nil {+ t.Fatal(err)+ }+ if len(docs) != 1 || docs[0].ID != "g1" {+ t.Fatal("go filter should have excluded the answer doc")+ }+ })+}++func TestListUserDocuments(t *testing.T) {+ ctx := context.Background()+ const userID = int64(5)+ const otherUserID = int64(9)++ t.Run("no filter calls ListUserKnowledgeDocuments with correct userID", func(t *testing.T) {+ var gotUserID string+ db := &mockDB{+ listUser: func(_ context.Context, uid sql.NullString) ([]database.ListUserKnowledgeDocumentsRow, error) {+ gotUserID = uid.String+ return nil, nil+ },+ }+ ks := &knowledgeStore{db: db}+ _, err := ks.ListUserDocuments(ctx, userID, nil, true)+ if err != nil {+ t.Fatal(err)+ }+ if gotUserID != "5" {+ t.Fatalf("expected userID=5, got %q", gotUserID)+ }+ })++ // SECURITY: flowID path must enforce user_id ownership in Go+ t.Run("SECURITY flowID filter excludes documents from other users", func(t *testing.T) {+ db := &mockDB{+ listFlow: func(_ context.Context, _ sql.NullString) ([]database.ListFlowKnowledgeDocumentsRow, error) {+ return []database.ListFlowKnowledgeDocumentsRow{+ makeListFlowRow("own", "", fmt.Sprintf(`{"doc_type":"guide","user_id":%d}`, userID)),+ makeListFlowRow("other", "", fmt.Sprintf(`{"doc_type":"guide","user_id":%d}`, otherUserID)),+ }, nil+ },+ }+ ks := &knowledgeStore{db: db}+ docs, err := ks.ListUserDocuments(ctx, userID, &model.KnowledgeFilter{FlowID: ptr(int64(1))}, true)+ if err != nil {+ t.Fatal(err)+ }+ if len(docs) != 1 || docs[0].ID != "own" {+ t.Fatalf("security violation: expected only own doc, got %d docs", len(docs))+ }+ })++ // SECURITY: user_id=0 (no user_id in cmetadata) should be excluded when+ // userID filter is active via the flow path+ t.Run("SECURITY doc without user_id is excluded for non-zero userID via flow path", func(t *testing.T) {+ db := &mockDB{+ listFlow: func(_ context.Context, _ sql.NullString) ([]database.ListFlowKnowledgeDocumentsRow, error) {+ return []database.ListFlowKnowledgeDocumentsRow{+ // no user_id key → UserID=0 after parse+ makeListFlowRow("missing", "", `{"doc_type":"answer"}`),+ makeListFlowRow("correct", "", fmt.Sprintf(`{"doc_type":"answer","user_id":%d}`, userID)),+ }, nil+ },+ }+ ks := &knowledgeStore{db: db}+ docs, err := ks.ListUserDocuments(ctx, userID, &model.KnowledgeFilter{FlowID: ptr(int64(1))}, true)+ if err != nil {+ t.Fatal(err)+ }+ if len(docs) != 1 || docs[0].ID != "correct" {+ t.Fatalf("doc with missing user_id must be excluded, got %d docs", len(docs))+ }+ })++ t.Run("db error propagates", func(t *testing.T) {+ db := &mockDB{+ listUser: func(_ context.Context, _ sql.NullString) ([]database.ListUserKnowledgeDocumentsRow, error) {+ return nil, errors.New("db error")+ },+ }+ ks := &knowledgeStore{db: db}+ _, err := ks.ListUserDocuments(ctx, userID, nil, true)+ if err == nil {+ t.Fatal("expected error")+ }+ })+}++// ============================================================================+// Tests: GetDocument / GetUserDocument+// ============================================================================++func TestGetDocument(t *testing.T) {+ ctx := context.Background()++ t.Run("success returns correctly mapped document", func(t *testing.T) {+ db := &mockDB{+ getKnowledge: func(_ context.Context, uuid string) (database.GetKnowledgeDocumentRow, error) {+ return makeRow(uuid, "content", `{"doc_type":"code","code_lang":"go"}`), nil+ },+ }+ ks := &knowledgeStore{db: db}+ doc, err := ks.GetDocument(ctx, "abc123")+ if err != nil {+ t.Fatal(err)+ }+ if doc.ID != "abc123" || doc.Content != "content" {+ t.Fatal("id/content mismatch")+ }+ if doc.DocType != model.KnowledgeDocTypeCode {+ t.Fatal("DocType mismatch")+ }+ if doc.CodeLang == nil || *doc.CodeLang != "go" {+ t.Fatal("CodeLang mismatch")+ }+ })++ t.Run("db error is wrapped and returned", func(t *testing.T) {+ db := &mockDB{+ getKnowledge: func(_ context.Context, _ string) (database.GetKnowledgeDocumentRow, error) {+ return database.GetKnowledgeDocumentRow{}, errors.New("not found")+ },+ }+ ks := &knowledgeStore{db: db}+ _, err := ks.GetDocument(ctx, "xyz")+ if err == nil {+ t.Fatal("expected error")+ }+ })+}++func TestGetUserDocument(t *testing.T) {+ ctx := context.Background()+ const userID = int64(7)++ t.Run("passes correct uuid and userID to db", func(t *testing.T) {+ var gotParams database.GetUserKnowledgeDocumentParams+ db := &mockDB{+ getUserKnowledge: func(_ context.Context, arg database.GetUserKnowledgeDocumentParams) (database.GetUserKnowledgeDocumentRow, error) {+ gotParams = arg+ return database.GetUserKnowledgeDocumentRow{+ ID: arg.Uuid,+ Document: "doc",+ Cmetadata: sql.NullString{String: `{"doc_type":"guide"}`, Valid: true},+ }, nil+ },+ }+ ks := &knowledgeStore{db: db}+ doc, err := ks.GetUserDocument(ctx, userID, "doc-uuid")+ if err != nil {+ t.Fatal(err)+ }+ if gotParams.Uuid != "doc-uuid" {+ t.Fatalf("uuid mismatch: %q", gotParams.Uuid)+ }+ if gotParams.Cmetadata.String != "7" {+ t.Fatalf("userID param mismatch: %q", gotParams.Cmetadata.String)+ }+ if doc.ID != "doc-uuid" {+ t.Fatal("document ID mismatch")+ }+ })++ // SECURITY: if the DB row is not found (wrong owner), an error is returned+ t.Run("SECURITY db not-found error propagates (ownership enforced at DB level)", func(t *testing.T) {+ db := &mockDB{+ getUserKnowledge: func(_ context.Context, _ database.GetUserKnowledgeDocumentParams) (database.GetUserKnowledgeDocumentRow, error) {+ return database.GetUserKnowledgeDocumentRow{}, errors.New("sql: no rows")+ },+ }+ ks := &knowledgeStore{db: db}+ _, err := ks.GetUserDocument(ctx, userID, "not-my-doc")+ if err == nil {+ t.Fatal("SECURITY: accessing another user's document must return error")+ }+ })+}++// ============================================================================+// Tests: DeleteDocument / DeleteUserDocument+// ============================================================================++func TestDeleteDocument(t *testing.T) {+ ctx := context.Background()+ const userID = int64(10)++ t.Run("success: fetches doc, deletes it and publishes event", func(t *testing.T) {+ pub := &mockPublisher{}+ db := &mockDB{+ getKnowledge: func(_ context.Context, uuid string) (database.GetKnowledgeDocumentRow, error) {+ return makeRow(uuid, "content", `{"doc_type":"answer"}`), nil+ },+ deleteKnowledge: func(_ context.Context, _ sql.NullString) error { return nil },+ }+ ks := &knowledgeStore{db: db, newKnp: newPublisherFactory(pub)}++ err := ks.DeleteDocument(ctx, userID, "doc1")+ if err != nil {+ t.Fatal(err)+ }+ if len(pub.deletedDocs) != 1 || pub.deletedDocs[0].ID != "doc1" {+ t.Fatal("KnowledgeDocumentDeleted event not published or wrong doc")+ }+ if pub.userID != userID {+ t.Fatalf("publisher userID mismatch: want %d, got %d", userID, pub.userID)+ }+ })++ t.Run("GetDocument error prevents deletion and no event", func(t *testing.T) {+ pub := &mockPublisher{}+ db := &mockDB{+ getKnowledge: func(_ context.Context, _ string) (database.GetKnowledgeDocumentRow, error) {+ return database.GetKnowledgeDocumentRow{}, errors.New("not found")+ },+ }+ ks := &knowledgeStore{db: db, newKnp: newPublisherFactory(pub)}++ err := ks.DeleteDocument(ctx, userID, "ghost")+ if err == nil {+ t.Fatal("expected error")+ }+ if len(pub.deletedDocs) != 0 {+ t.Fatal("no event should be published when fetch fails")+ }+ })++ t.Run("delete db error propagates and no event", func(t *testing.T) {+ pub := &mockPublisher{}+ db := &mockDB{+ getKnowledge: func(_ context.Context, uuid string) (database.GetKnowledgeDocumentRow, error) {+ return makeRow(uuid, "", `{}`), nil+ },+ deleteKnowledge: func(_ context.Context, _ sql.NullString) error {+ return errors.New("db delete error")+ },+ }+ ks := &knowledgeStore{db: db, newKnp: newPublisherFactory(pub)}++ err := ks.DeleteDocument(ctx, userID, "d1")+ if err == nil {+ t.Fatal("expected error")+ }+ if len(pub.deletedDocs) != 0 {+ t.Fatal("no event when delete fails")+ }+ })+}++func TestDeleteUserDocument(t *testing.T) {+ ctx := context.Background()+ const userID = int64(3)++ t.Run("success: ownership-checked fetch, delete and event", func(t *testing.T) {+ pub := &mockPublisher{}+ var gotDelParams database.DeleteUserKnowledgeDocumentParams+ db := &mockDB{+ getUserKnowledge: func(_ context.Context, arg database.GetUserKnowledgeDocumentParams) (database.GetUserKnowledgeDocumentRow, error) {+ return database.GetUserKnowledgeDocumentRow{+ ID: arg.Uuid,+ Document: "doc",+ Cmetadata: sql.NullString{String: `{"doc_type":"answer"}`, Valid: true},+ }, nil+ },+ deleteUserKnowledge: func(_ context.Context, arg database.DeleteUserKnowledgeDocumentParams) error {+ gotDelParams = arg+ return nil+ },+ }+ ks := &knowledgeStore{db: db, newKnp: newPublisherFactory(pub)}++ err := ks.DeleteUserDocument(ctx, userID, "my-doc")+ if err != nil {+ t.Fatal(err)+ }+ // Ownership enforced: correct uuid and userID sent to DB+ if gotDelParams.Column1.String != "my-doc" {+ t.Fatalf("uuid param: want my-doc, got %q", gotDelParams.Column1.String)+ }+ if gotDelParams.Column2.String != "3" {+ t.Fatalf("user_id param: want 3, got %q", gotDelParams.Column2.String)+ }+ if len(pub.deletedDocs) != 1 {+ t.Fatal("event not published")+ }+ })++ // SECURITY: GetUserDocument returns error → no delete, no event+ t.Run("SECURITY: fetching another user's doc aborts deletion", func(t *testing.T) {+ pub := &mockPublisher{}+ db := &mockDB{+ getUserKnowledge: func(_ context.Context, _ database.GetUserKnowledgeDocumentParams) (database.GetUserKnowledgeDocumentRow, error) {+ return database.GetUserKnowledgeDocumentRow{}, errors.New("not found")+ },+ }+ ks := &knowledgeStore{db: db, newKnp: newPublisherFactory(pub)}++ err := ks.DeleteUserDocument(ctx, userID, "other-doc")+ if err == nil {+ t.Fatal("SECURITY: must fail when doc does not belong to user")+ }+ if len(pub.deletedDocs) != 0 {+ t.Fatal("no event should be emitted on failure")+ }+ })++ t.Run("db delete failure propagates, no event", func(t *testing.T) {+ pub := &mockPublisher{}+ db := &mockDB{+ getUserKnowledge: func(_ context.Context, arg database.GetUserKnowledgeDocumentParams) (database.GetUserKnowledgeDocumentRow, error) {+ return database.GetUserKnowledgeDocumentRow{+ ID: arg.Uuid,+ Document: "",+ Cmetadata: sql.NullString{Valid: false},+ }, nil+ },+ deleteUserKnowledge: func(_ context.Context, _ database.DeleteUserKnowledgeDocumentParams) error {+ return errors.New("constraint violation")+ },+ }+ ks := &knowledgeStore{db: db, newKnp: newPublisherFactory(pub)}++ err := ks.DeleteUserDocument(ctx, userID, "doc")+ if err == nil {+ t.Fatal("expected error from db delete")+ }+ if len(pub.deletedDocs) != 0 {+ t.Fatal("no event on failure")+ }+ })+}++// ============================================================================+// Tests: CreateDocument+// ============================================================================++func TestCreateDocument(t *testing.T) {+ ctx := context.Background()+ const userID = int64(11)++ t.Run("store nil returns error immediately", func(t *testing.T) {+ ks := &knowledgeStore{store: nil}+ _, err := ks.CreateDocument(ctx, userID, model.CreateKnowledgeDocumentInput{+ DocType: model.KnowledgeDocTypeAnswer, Content: "x", Question: "q",+ })+ if err == nil {+ t.Fatal("expected error when store is nil")+ }+ })++ t.Run("store AddDocuments error propagates", func(t *testing.T) {+ vs := &mockVectorStore{+ addDocumentsFn: func(_ context.Context, _ []schema.Document, _ ...vectorstores.Option) ([]string, error) {+ return nil, errors.New("vector db error")+ },+ }+ ks := &knowledgeStore{store: vs, newKnp: newPublisherFactory(&mockPublisher{})}+ _, err := ks.CreateDocument(ctx, userID, model.CreateKnowledgeDocumentInput{+ DocType: model.KnowledgeDocTypeGuide, Content: "c", Question: "q",+ })+ if err == nil {+ t.Fatal("expected error from AddDocuments")+ }+ })++ t.Run("AddDocuments returning no IDs is an error", func(t *testing.T) {+ vs := &mockVectorStore{+ addDocumentsFn: func(_ context.Context, _ []schema.Document, _ ...vectorstores.Option) ([]string, error) {+ return []string{}, nil // empty slice+ },+ }+ ks := &knowledgeStore{store: vs, newKnp: newPublisherFactory(&mockPublisher{})}+ _, err := ks.CreateDocument(ctx, userID, model.CreateKnowledgeDocumentInput{+ DocType: model.KnowledgeDocTypeAnswer, Content: "c", Question: "q",+ })+ if err == nil {+ t.Fatal("expected error for empty IDs")+ }+ })++ t.Run("success: all fields set, manual=true, user_id present, event published", func(t *testing.T) {+ pub := &mockPublisher{}+ var capturedDocs []schema.Document+ vs := &mockVectorStore{+ addDocumentsFn: func(_ context.Context, docs []schema.Document, _ ...vectorstores.Option) ([]string, error) {+ capturedDocs = docs+ return []string{"new-uuid"}, nil+ },+ }+ ks := &knowledgeStore{store: vs, newKnp: newPublisherFactory(pub)}++ input := model.CreateKnowledgeDocumentInput{+ DocType: model.KnowledgeDocTypeCode,+ Content: " func main() {} ", // surrounding spaces trimmed+ Question: "how to main?",+ Description: ptr("a Go main"),+ CodeLang: ptr("go"),+ }+ doc, err := ks.CreateDocument(ctx, userID, input)+ if err != nil {+ t.Fatal(err)+ }++ // Returned document+ if doc.ID != "new-uuid" {+ t.Fatalf("id mismatch: %q", doc.ID)+ }+ if doc.Content != "func main() {}" {+ t.Fatalf("content not trimmed: %q", doc.Content)+ }+ if !doc.Manual {+ t.Fatal("manual must be true for manually created docs")+ }++ // Metadata stored in pgvector+ if len(capturedDocs) != 1 {+ t.Fatal("expected exactly one document passed to AddDocuments")+ }+ meta := capturedDocs[0].Metadata+ if meta["user_id"] != userID {+ t.Fatalf("user_id in metadata: want %d, got %v", userID, meta["user_id"])+ }+ if meta["manual"] != true {+ t.Fatal("manual flag must be true in metadata")+ }+ if meta["code_lang"] != "go" {+ t.Fatal("code_lang missing from metadata")+ }++ // Returned model must carry the creator's UserID+ if doc.UserID != userID {+ t.Fatalf("doc.UserID: want %d, got %d", userID, doc.UserID)+ }++ // Event+ if len(pub.createdDocs) != 1 || pub.createdDocs[0].ID != "new-uuid" {+ t.Fatal("KnowledgeDocumentCreated event not published correctly")+ }+ if pub.userID != userID {+ t.Fatalf("publisher userID: want %d, got %d", userID, pub.userID)+ }+ })++ t.Run("content is trimmed of whitespace", func(t *testing.T) {+ var capturedContent string+ vs := &mockVectorStore{+ addDocumentsFn: func(_ context.Context, docs []schema.Document, _ ...vectorstores.Option) ([]string, error) {+ capturedContent = docs[0].PageContent+ return []string{"id"}, nil+ },+ }+ ks := &knowledgeStore{store: vs, newKnp: newPublisherFactory(&mockPublisher{})}+ _, err := ks.CreateDocument(ctx, userID, model.CreateKnowledgeDocumentInput{+ DocType: model.KnowledgeDocTypeAnswer, Content: " trimmed ", Question: "q",+ })+ if err != nil {+ t.Fatal(err)+ }+ if capturedContent != "trimmed" {+ t.Fatalf("expected trimmed content, got %q", capturedContent)+ }+ })++ t.Run("optional fields absent means nil in model", func(t *testing.T) {+ vs := &mockVectorStore{+ addDocumentsFn: func(_ context.Context, _ []schema.Document, _ ...vectorstores.Option) ([]string, error) {+ return []string{"id"}, nil+ },+ }+ ks := &knowledgeStore{store: vs, newKnp: newPublisherFactory(&mockPublisher{})}+ doc, err := ks.CreateDocument(ctx, userID, model.CreateKnowledgeDocumentInput{+ DocType: model.KnowledgeDocTypeAnswer, Content: "c", Question: "q",+ })+ if err != nil {+ t.Fatal(err)+ }+ if doc.Description != nil || doc.GuideType != nil || doc.AnswerType != nil || doc.CodeLang != nil {+ t.Fatal("optional fields should be nil when not provided")+ }+ })+}++// ============================================================================+// Tests: UpdateDocument / UpdateUserDocument+// ============================================================================++func TestUpdateDocument(t *testing.T) {+ ctx := context.Background()+ const userID = int64(20)++ existingMeta := `{"doc_type":"guide","guide_type":"pentest","question":"old q","part_size":5,"total_size":5}`+ successDB := func(overrideGet ...func(string) (database.GetKnowledgeDocumentRow, error)) *mockDB {+ getFn := func(uuid string) (database.GetKnowledgeDocumentRow, error) {+ return makeRow(uuid, "old content", existingMeta), nil+ }+ if len(overrideGet) > 0 {+ getFn = overrideGet[0]+ }+ return &mockDB{+ getKnowledge: func(_ context.Context, uuid string) (database.GetKnowledgeDocumentRow, error) {+ return getFn(uuid)+ },+ updateKnowledge: func(_ context.Context, arg database.UpdateKnowledgeDocumentParams) (database.UpdateKnowledgeDocumentRow, error) {+ return database.UpdateKnowledgeDocumentRow{+ ID: arg.Column1.String,+ Document: arg.Column3.String,+ Cmetadata: sql.NullString{String: existingMeta, Valid: true},+ }, nil+ },+ }+ }++ t.Run("embedder nil returns error", func(t *testing.T) {+ ks := &knowledgeStore{+ db: successDB(),+ embedder: nil,+ }+ _, err := ks.UpdateDocument(ctx, userID, "id1", model.UpdateKnowledgeDocumentInput{Content: "new"})+ if err == nil {+ t.Fatal("expected error when embedder is nil")+ }+ })++ t.Run("embedder unavailable returns error", func(t *testing.T) {+ ks := &knowledgeStore{+ db: successDB(),+ embedder: &mockEmbedder{available: false},+ }+ _, err := ks.UpdateDocument(ctx, userID, "id1", model.UpdateKnowledgeDocumentInput{Content: "new"})+ if err == nil {+ t.Fatal("expected error when embedder unavailable")+ }+ })++ t.Run("EmbedDocuments error propagates", func(t *testing.T) {+ ks := &knowledgeStore{+ db: successDB(),+ embedder: &mockEmbedder{+ available: true,+ embedDocumentsFn: func(_ context.Context, _ []string) ([][]float32, error) {+ return nil, errors.New("embed error")+ },+ },+ }+ _, err := ks.UpdateDocument(ctx, userID, "id1", model.UpdateKnowledgeDocumentInput{Content: "new"})+ if err == nil {+ t.Fatal("expected error from EmbedDocuments")+ }+ })++ t.Run("embedder returning empty vectors is an error", func(t *testing.T) {+ ks := &knowledgeStore{+ db: successDB(),+ embedder: &mockEmbedder{+ available: true,+ embedDocumentsFn: func(_ context.Context, _ []string) ([][]float32, error) {+ return [][]float32{}, nil+ },+ },+ }+ _, err := ks.UpdateDocument(ctx, userID, "id1", model.UpdateKnowledgeDocumentInput{Content: "new"})+ if err == nil {+ t.Fatal("expected error for empty vectors")+ }+ })++ t.Run("db update error propagates", func(t *testing.T) {+ db := &mockDB{+ getKnowledge: func(_ context.Context, uuid string) (database.GetKnowledgeDocumentRow, error) {+ return makeRow(uuid, "old", existingMeta), nil+ },+ updateKnowledge: func(_ context.Context, _ database.UpdateKnowledgeDocumentParams) (database.UpdateKnowledgeDocumentRow, error) {+ return database.UpdateKnowledgeDocumentRow{}, errors.New("constraint error")+ },+ }+ ks := &knowledgeStore{+ db: db,+ embedder: &mockEmbedder{available: true},+ }+ _, err := ks.UpdateDocument(ctx, userID, "id1", model.UpdateKnowledgeDocumentInput{Content: "new"})+ if err == nil {+ t.Fatal("expected error from db update")+ }+ })++ t.Run("success: metadata merged, embedding computed, event published", func(t *testing.T) {+ pub := &mockPublisher{}+ var gotParams database.UpdateKnowledgeDocumentParams++ db := &mockDB{+ getKnowledge: func(_ context.Context, uuid string) (database.GetKnowledgeDocumentRow, error) {+ return makeRow(uuid, "old content", `{"doc_type":"guide","guide_type":"pentest","question":"original"}`), nil+ },+ updateKnowledge: func(_ context.Context, arg database.UpdateKnowledgeDocumentParams) (database.UpdateKnowledgeDocumentRow, error) {+ gotParams = arg+ return database.UpdateKnowledgeDocumentRow{+ ID: arg.Column1.String,+ Document: arg.Column3.String,+ Cmetadata: sql.NullString{+ String: `{"doc_type":"guide","guide_type":"pentest","question":"new q"}`,+ Valid: true,+ },+ }, nil+ },+ }+ ks := &knowledgeStore{+ db: db,+ embedder: &mockEmbedder{available: true},+ newKnp: newPublisherFactory(pub),+ }++ doc, err := ks.UpdateDocument(ctx, userID, "doc-id", model.UpdateKnowledgeDocumentInput{+ Content: "new content",+ Question: ptr("new q"),+ })+ if err != nil {+ t.Fatal(err)+ }++ // Correct uuid passed to update+ if gotParams.Column1.String != "doc-id" {+ t.Fatalf("uuid mismatch: %q", gotParams.Column1.String)+ }+ // New content passed+ if gotParams.Column3.String != "new content" {+ t.Fatalf("document mismatch: %q", gotParams.Column3.String)+ }+ // Embedding formatted as vector literal+ if gotParams.Column2 == "" || gotParams.Column2[0] != '[' {+ t.Fatalf("embedding format wrong: %q", gotParams.Column2)+ }++ // Updated doc returned+ if doc.ID != "doc-id" {+ t.Fatal("doc ID mismatch")+ }+ // Event published+ if len(pub.updatedDocs) != 1 {+ t.Fatal("KnowledgeDocumentUpdated event not published")+ }+ if pub.userID != userID {+ t.Fatalf("publisher userID: want %d, got %d", userID, pub.userID)+ }+ })+}++func TestUpdateDocumentPreservesOriginalOwner(t *testing.T) {+ // SECURITY: when an admin (userID=1) updates a document that belongs to+ // user 99, the stored user_id in cmetadata must remain 99, not be replaced+ // by 1. The admin's identity is used only for event scoping.+ ctx := context.Background()+ const adminID = int64(1)+ const originalOwner = int64(99)++ originalMeta := fmt.Sprintf(`{"doc_type":"answer","user_id":%d,"question":"q"}`, originalOwner)++ var storedMeta string+ db := &mockDB{+ getKnowledge: func(_ context.Context, uuid string) (database.GetKnowledgeDocumentRow, error) {+ return makeRow(uuid, "old", originalMeta), nil+ },+ updateKnowledge: func(_ context.Context, arg database.UpdateKnowledgeDocumentParams) (database.UpdateKnowledgeDocumentRow, error) {+ storedMeta = string(arg.Column4.RawMessage)+ return database.UpdateKnowledgeDocumentRow{+ ID: arg.Column1.String,+ Document: arg.Column3.String,+ Cmetadata: sql.NullString{+ String: string(arg.Column4.RawMessage),+ Valid: true,+ },+ }, nil+ },+ }+ pub := &mockPublisher{}+ ks := &knowledgeStore{+ db: db,+ embedder: &mockEmbedder{available: true},+ newKnp: newPublisherFactory(pub),+ }++ doc, err := ks.UpdateDocument(ctx, adminID, "doc", model.UpdateKnowledgeDocumentInput{Content: "new"})+ if err != nil {+ t.Fatal(err)+ }++ // The returned document must carry the original owner, not the admin+ if doc.UserID != originalOwner {+ t.Fatalf("SECURITY: doc.UserID should be original owner %d, got %d", originalOwner, doc.UserID)+ }++ // The cmetadata written to DB must also preserve the original owner+ parsed := parseMeta(storedMeta)+ if parsed.UserID != originalOwner {+ t.Fatalf("SECURITY: cmetadata user_id should be %d, got %d", originalOwner, parsed.UserID)+ }++ // Publisher is still scoped to the admin who performed the update+ if pub.userID != adminID {+ t.Fatalf("publisher userID should be admin %d, got %d", adminID, pub.userID)+ }+}++func TestUpdateUserDocument(t *testing.T) {+ ctx := context.Background()+ const userID = int64(30)++ existingMeta := `{"doc_type":"answer","answer_type":"tool","question":"q"}`++ t.Run("success uses GetUserDocument (ownership check)", func(t *testing.T) {+ pub := &mockPublisher{}+ var fetchedUUID, fetchedUserID string++ db := &mockDB{+ getUserKnowledge: func(_ context.Context, arg database.GetUserKnowledgeDocumentParams) (database.GetUserKnowledgeDocumentRow, error) {+ fetchedUUID = arg.Uuid+ fetchedUserID = arg.Cmetadata.String+ return database.GetUserKnowledgeDocumentRow{+ ID: arg.Uuid,+ Document: "old",+ Cmetadata: sql.NullString{String: existingMeta, Valid: true},+ }, nil+ },+ updateKnowledge: func(_ context.Context, arg database.UpdateKnowledgeDocumentParams) (database.UpdateKnowledgeDocumentRow, error) {+ return database.UpdateKnowledgeDocumentRow{+ ID: arg.Column1.String,+ Document: arg.Column3.String,+ Cmetadata: sql.NullString{+ String: existingMeta,+ Valid: true,+ },+ }, nil+ },+ }+ ks := &knowledgeStore{+ db: db,+ embedder: &mockEmbedder{available: true},+ newKnp: newPublisherFactory(pub),+ }++ _, err := ks.UpdateUserDocument(ctx, userID, "my-doc", model.UpdateKnowledgeDocumentInput{Content: "updated"})+ if err != nil {+ t.Fatal(err)+ }+ if fetchedUUID != "my-doc" {+ t.Fatal("wrong uuid fetched")+ }+ if fetchedUserID != "30" {+ t.Fatalf("wrong userID passed to GetUserDocument: %q", fetchedUserID)+ }+ })++ // SECURITY: if GetUserDocument fails (wrong owner), update is blocked+ t.Run("SECURITY: wrong owner causes update to fail", func(t *testing.T) {+ db := &mockDB{+ getUserKnowledge: func(_ context.Context, _ database.GetUserKnowledgeDocumentParams) (database.GetUserKnowledgeDocumentRow, error) {+ return database.GetUserKnowledgeDocumentRow{}, errors.New("not found")+ },+ }+ ks := &knowledgeStore{+ db: db,+ embedder: &mockEmbedder{available: true},+ }+ _, err := ks.UpdateUserDocument(ctx, userID, "not-my-doc", model.UpdateKnowledgeDocumentInput{Content: "evil update"})+ if err == nil {+ t.Fatal("SECURITY: update of another user's document must be rejected")+ }+ })+}diff --git a/backend/pkg/database/models.go b/backend/pkg/database/models.goindex 1672901d..87440446 100644--- a/backend/pkg/database/models.go+++ b/backend/pkg/database/models.go@@ -9,6 +9,9 @@ import ("database/sql/driver""encoding/json""fmt"++ "github.com/google/uuid"+ "github.com/sqlc-dev/pqtype")type AssistantStatus string@@ -955,6 +958,20 @@ type FlowTemplate struct {UpdatedAt sql.NullTime `json:"updated_at"`}+type LangchainPgCollection struct {+ Name sql.NullString `json:"name"`+ Cmetadata pqtype.NullRawMessage `json:"cmetadata"`+ Uuid uuid.UUID `json:"uuid"`+}++type LangchainPgEmbedding struct {+ CollectionID uuid.NullUUID `json:"collection_id"`+ Embedding string `json:"embedding"`+ Document sql.NullString `json:"document"`+ Cmetadata pqtype.NullRawMessage `json:"cmetadata"`+ Uuid uuid.UUID `json:"uuid"`+}+type Msgchain struct {ID int64 `json:"id"`Type MsgchainType `json:"type"`diff --git a/backend/pkg/database/querier.go b/backend/pkg/database/querier.goindex 11c8ee98..0cfa6e73 100644--- a/backend/pkg/database/querier.go+++ b/backend/pkg/database/querier.go@@ -38,7 +38,14 @@ type Querier interface {DeleteFavoriteFlow(ctx context.Context, arg DeleteFavoriteFlowParams) (UserPreference, error)DeleteFlow(ctx context.Context, id int64) (Flow, error)DeleteFlowAssistantLog(ctx context.Context, id int64) error+ // Delete all memory-type documents for a specific flow.+ // Called on flow deletion to free long-term memory that will never be re-used.+ // $1 is the decimal text representation of the flow ID (e.g. "55"), matching the+ // text result of (cmetadata ->> 'flow_id') which uses JSON ->> extraction.+ DeleteFlowMemoryDocuments(ctx context.Context, dollar_1 sql.NullString) errorDeleteFlowTemplate(ctx context.Context, arg DeleteFlowTemplateParams) error+ // Delete a knowledge document by UUID (admin — no user_id check).+ DeleteKnowledgeDocument(ctx context.Context, dollar_1 sql.NullString) errorDeletePrompt(ctx context.Context, id int64) errorDeleteProvider(ctx context.Context, id int64) (Provider, error)DeleteSubtask(ctx context.Context, id int64) error@@ -46,6 +53,8 @@ type Querier interface {DeleteUser(ctx context.Context, id int64) errorDeleteUserAPIToken(ctx context.Context, arg DeleteUserAPITokenParams) (ApiToken, error)DeleteUserAPITokenByTokenID(ctx context.Context, arg DeleteUserAPITokenByTokenIDParams) (ApiToken, error)+ // Delete a knowledge document by UUID, only if it belongs to the given user.+ DeleteUserKnowledgeDocument(ctx context.Context, arg DeleteUserKnowledgeDocumentParams) errorDeleteUserPreferences(ctx context.Context, userID int64) errorDeleteUserPrompt(ctx context.Context, arg DeleteUserPromptParams) errorDeleteUserProvider(ctx context.Context, arg DeleteUserProviderParams) (Provider, error)@@ -112,6 +121,8 @@ type Querier interface {GetFlowsStatsByDayLastMonth(ctx context.Context, userID int64) ([]GetFlowsStatsByDayLastMonthRow, error)// Get flows stats by day for the last weekGetFlowsStatsByDayLastWeek(ctx context.Context, userID int64) ([]GetFlowsStatsByDayLastWeekRow, error)+ // Fetch a single knowledge document by its UUID (admin view — no user_id check).+ GetKnowledgeDocument(ctx context.Context, uuid string) (GetKnowledgeDocumentRow, error)GetMsgChain(ctx context.Context, id int64) (Msgchain, error)// Get all msgchains for a flow (including task and subtask level)GetMsgchainsForFlow(ctx context.Context, flowID int64) ([]GetMsgchainsForFlowRow, error)@@ -202,6 +213,8 @@ type Querier interface {GetUserFlowTermLogs(ctx context.Context, arg GetUserFlowTermLogsParams) ([]Termlog, error)GetUserFlowVectorStoreLogs(ctx context.Context, arg GetUserFlowVectorStoreLogsParams) ([]Vecstorelog, error)GetUserFlows(ctx context.Context, userID int64) ([]Flow, error)+ // Fetch a single knowledge document by UUID, scoped to a specific user.+ GetUserKnowledgeDocument(ctx context.Context, arg GetUserKnowledgeDocumentParams) (GetUserKnowledgeDocumentRow, error)GetUserPreferencesByUserID(ctx context.Context, userID int64) (UserPreference, error)GetUserPrompt(ctx context.Context, arg GetUserPromptParams) (Prompt, error)GetUserPromptByType(ctx context.Context, arg GetUserPromptByTypeParams) (Prompt, error)@@ -222,6 +235,12 @@ type Querier interface {GetUserTotalToolcallsStats(ctx context.Context, userID int64) (GetUserTotalToolcallsStatsRow, error)GetUserTotalUsageStats(ctx context.Context, userID int64) (GetUserTotalUsageStatsRow, error)GetUsers(ctx context.Context) ([]GetUsersRow, error)+ // List all knowledge documents excluding the noisy memory type (admin view).+ ListAllKnowledgeDocuments(ctx context.Context) ([]ListAllKnowledgeDocumentsRow, error)+ // List non-memory knowledge documents belonging to a specific flow (admin scoped).+ ListFlowKnowledgeDocuments(ctx context.Context, cmetadata sql.NullString) ([]ListFlowKnowledgeDocumentsRow, error)+ // List all non-memory knowledge documents owned by a specific user (user-scoped view).+ ListUserKnowledgeDocuments(ctx context.Context, cmetadata sql.NullString) ([]ListUserKnowledgeDocumentsRow, error)UpdateAPIToken(ctx context.Context, arg UpdateAPITokenParams) (ApiToken, error)UpdateAssistant(ctx context.Context, arg UpdateAssistantParams) (Assistant, error)UpdateAssistantLanguage(ctx context.Context, arg UpdateAssistantLanguageParams) (Assistant, error)@@ -243,6 +262,10 @@ type Querier interface {UpdateFlowTemplate(ctx context.Context, arg UpdateFlowTemplateParams) (FlowTemplate, error)UpdateFlowTitle(ctx context.Context, arg UpdateFlowTitleParams) (Flow, error)UpdateFlowToolCallIDTemplate(ctx context.Context, arg UpdateFlowToolCallIDTemplateParams) (Flow, error)+ // Update an existing document's embedding, text and metadata atomically.+ // $2 must be formatted as a PostgreSQL vector literal: '[f1,f2,...]'+ // $4 must be valid JSON text.+ UpdateKnowledgeDocument(ctx context.Context, arg UpdateKnowledgeDocumentParams) (UpdateKnowledgeDocumentRow, error)UpdateMsgChain(ctx context.Context, arg UpdateMsgChainParams) (Msgchain, error)UpdateMsgChainUsage(ctx context.Context, arg UpdateMsgChainUsageParams) (Msgchain, error)UpdateMsgLogResult(ctx context.Context, arg UpdateMsgLogResultParams) (Msglog, error)diff --git a/backend/pkg/graph/generated.go b/backend/pkg/graph/generated.goindex 5b5bb569..c8c1e6ef 100644--- a/backend/pkg/graph/generated.go+++ b/backend/pkg/graph/generated.go@@ -280,6 +280,29 @@ type ComplexityRoot struct {TotalDurationSeconds func(childComplexity int) int}+ KnowledgeDocument struct {+ AnswerType func(childComplexity int) int+ CodeLang func(childComplexity int) int+ Content func(childComplexity int) int+ Description func(childComplexity int) int+ DocType func(childComplexity int) int+ FlowID func(childComplexity int) int+ GuideType func(childComplexity int) int+ ID func(childComplexity int) int+ Manual func(childComplexity int) int+ PartSize func(childComplexity int) int+ Question func(childComplexity int) int+ SubtaskID func(childComplexity int) int+ TaskID func(childComplexity int) int+ TotalSize func(childComplexity int) int+ UserID func(childComplexity int) int+ }++ KnowledgeDocumentWithScore struct {+ Document func(childComplexity int) int+ Score func(childComplexity int) int+ }+MessageLog struct {CreatedAt func(childComplexity int) intFlowID func(childComplexity int) int@@ -322,33 +345,36 @@ type ComplexityRoot struct {}Mutation struct {- AddFavoriteFlow func(childComplexity int, flowID int64) int- CallAssistant func(childComplexity int, flowID int64, assistantID int64, input string, useAgents bool, resourceIds []int64) int- CreateAPIToken func(childComplexity int, input model.CreateAPITokenInput) int- CreateAssistant func(childComplexity int, flowID int64, modelProvider string, input string, useAgents bool, resourceIds []int64) int- CreateFlow func(childComplexity int, modelProvider string, input string, resourceIds []int64) int- CreateFlowTemplate func(childComplexity int, input model.CreateFlowTemplateInput) int- CreatePrompt func(childComplexity int, typeArg model.PromptType, template string) int- CreateProvider func(childComplexity int, name string, typeArg model.ProviderType, agents model.AgentsConfig) int- DeleteAPIToken func(childComplexity int, tokenID string) int- DeleteAssistant func(childComplexity int, flowID int64, assistantID int64) int- DeleteFavoriteFlow func(childComplexity int, flowID int64) int- DeleteFlow func(childComplexity int, flowID int64) int- DeleteFlowTemplate func(childComplexity int, templateID int64) int- DeletePrompt func(childComplexity int, promptID int64) int- DeleteProvider func(childComplexity int, providerID int64) int- FinishFlow func(childComplexity int, flowID int64) int- PutUserInput func(childComplexity int, flowID int64, input string, modelProvider *string, resourceIds []int64) int- RenameFlow func(childComplexity int, flowID int64, title string) int- StopAssistant func(childComplexity int, flowID int64, assistantID int64) int- StopFlow func(childComplexity int, flowID int64) int- TestAgent func(childComplexity int, typeArg model.ProviderType, agentType model.AgentConfigType, agent model.AgentConfig) int- TestProvider func(childComplexity int, typeArg model.ProviderType, agents model.AgentsConfig) int- UpdateAPIToken func(childComplexity int, tokenID string, input model.UpdateAPITokenInput) int- UpdateFlowTemplate func(childComplexity int, templateID int64, input model.UpdateFlowTemplateInput) int- UpdatePrompt func(childComplexity int, promptID int64, template string) int- UpdateProvider func(childComplexity int, providerID int64, name string, agents model.AgentsConfig) int- ValidatePrompt func(childComplexity int, typeArg model.PromptType, template string) int+ AddFavoriteFlow func(childComplexity int, flowID int64) int+ CallAssistant func(childComplexity int, flowID int64, assistantID int64, input string, useAgents bool, resourceIds []int64) int+ CreateAPIToken func(childComplexity int, input model.CreateAPITokenInput) int+ CreateAssistant func(childComplexity int, flowID int64, modelProvider string, input string, useAgents bool, resourceIds []int64) int+ CreateFlow func(childComplexity int, modelProvider string, input string, resourceIds []int64) int+ CreateFlowTemplate func(childComplexity int, input model.CreateFlowTemplateInput) int+ CreateKnowledgeDocument func(childComplexity int, input model.CreateKnowledgeDocumentInput) int+ CreatePrompt func(childComplexity int, typeArg model.PromptType, template string) int+ CreateProvider func(childComplexity int, name string, typeArg model.ProviderType, agents model.AgentsConfig) int+ DeleteAPIToken func(childComplexity int, tokenID string) int+ DeleteAssistant func(childComplexity int, flowID int64, assistantID int64) int+ DeleteFavoriteFlow func(childComplexity int, flowID int64) int+ DeleteFlow func(childComplexity int, flowID int64) int+ DeleteFlowTemplate func(childComplexity int, templateID int64) int+ DeleteKnowledgeDocument func(childComplexity int, id string) int+ DeletePrompt func(childComplexity int, promptID int64) int+ DeleteProvider func(childComplexity int, providerID int64) int+ FinishFlow func(childComplexity int, flowID int64) int+ PutUserInput func(childComplexity int, flowID int64, input string, modelProvider *string, resourceIds []int64) int+ RenameFlow func(childComplexity int, flowID int64, title string) int+ StopAssistant func(childComplexity int, flowID int64, assistantID int64) int+ StopFlow func(childComplexity int, flowID int64) int+ TestAgent func(childComplexity int, typeArg model.ProviderType, agentType model.AgentConfigType, agent model.AgentConfig) int+ TestProvider func(childComplexity int, typeArg model.ProviderType, agents model.AgentsConfig) int+ UpdateAPIToken func(childComplexity int, tokenID string, input model.UpdateAPITokenInput) int+ UpdateFlowTemplate func(childComplexity int, templateID int64, input model.UpdateFlowTemplateInput) int+ UpdateKnowledgeDocument func(childComplexity int, id string, input model.UpdateKnowledgeDocumentInput) int+ UpdatePrompt func(childComplexity int, promptID int64, template string) int+ UpdateProvider func(childComplexity int, providerID int64, name string, agents model.AgentsConfig) int+ ValidatePrompt func(childComplexity int, typeArg model.PromptType, template string) int}PromptValidationResult struct {@@ -447,10 +473,13 @@ type ComplexityRoot struct {FlowsExecutionStatsByPeriod func(childComplexity int, period model.UsageStatsPeriod) intFlowsStatsByPeriod func(childComplexity int, period model.UsageStatsPeriod) intFlowsStatsTotal func(childComplexity int) int+ KnowledgeDocument func(childComplexity int, id string) int+ KnowledgeDocuments func(childComplexity int, filter *model.KnowledgeFilter, withContent bool) intMessageLogs func(childComplexity int, flowID int64) intProviders func(childComplexity int) intResources func(childComplexity int, path *string, recursive *bool) intScreenshots func(childComplexity int, flowID int64) int+ SearchKnowledge func(childComplexity int, query string, filter *model.KnowledgeFilter, limit *int) intSearchLogs func(childComplexity int, flowID int64) intSettings func(childComplexity int) intSettingsPrompts func(childComplexity int) int@@ -510,39 +539,42 @@ type ComplexityRoot struct {}Subscription struct {- APITokenCreated func(childComplexity int) int- APITokenDeleted func(childComplexity int) int- APITokenUpdated func(childComplexity int) int- AgentLogAdded func(childComplexity int, flowID int64) int- AssistantCreated func(childComplexity int, flowID int64) int- AssistantDeleted func(childComplexity int, flowID int64) int- AssistantLogAdded func(childComplexity int, flowID int64) int- AssistantLogUpdated func(childComplexity int, flowID int64) int- AssistantUpdated func(childComplexity int, flowID int64) int- FlowCreated func(childComplexity int) int- FlowDeleted func(childComplexity int) int- FlowFileAdded func(childComplexity int, flowID int64) int- FlowFileDeleted func(childComplexity int, flowID int64) int- FlowFileUpdated func(childComplexity int, flowID int64) int- FlowTemplateCreated func(childComplexity int) int- FlowTemplateDeleted func(childComplexity int) int- FlowTemplateUpdated func(childComplexity int) int- FlowUpdated func(childComplexity int) int- MessageLogAdded func(childComplexity int, flowID int64) int- MessageLogUpdated func(childComplexity int, flowID int64) int- ProviderCreated func(childComplexity int) int- ProviderDeleted func(childComplexity int) int- ProviderUpdated func(childComplexity int) int- ResourceAdded func(childComplexity int) int- ResourceDeleted func(childComplexity int) int- ResourceUpdated func(childComplexity int) int- ScreenshotAdded func(childComplexity int, flowID int64) int- SearchLogAdded func(childComplexity int, flowID int64) int- SettingsUserUpdated func(childComplexity int) int- TaskCreated func(childComplexity int, flowID int64) int- TaskUpdated func(childComplexity int, flowID int64) int- TerminalLogAdded func(childComplexity int, flowID int64) int- VectorStoreLogAdded func(childComplexity int, flowID int64) int+ APITokenCreated func(childComplexity int) int+ APITokenDeleted func(childComplexity int) int+ APITokenUpdated func(childComplexity int) int+ AgentLogAdded func(childComplexity int, flowID int64) int+ AssistantCreated func(childComplexity int, flowID int64) int+ AssistantDeleted func(childComplexity int, flowID int64) int+ AssistantLogAdded func(childComplexity int, flowID int64) int+ AssistantLogUpdated func(childComplexity int, flowID int64) int+ AssistantUpdated func(childComplexity int, flowID int64) int+ FlowCreated func(childComplexity int) int+ FlowDeleted func(childComplexity int) int+ FlowFileAdded func(childComplexity int, flowID int64) int+ FlowFileDeleted func(childComplexity int, flowID int64) int+ FlowFileUpdated func(childComplexity int, flowID int64) int+ FlowTemplateCreated func(childComplexity int) int+ FlowTemplateDeleted func(childComplexity int) int+ FlowTemplateUpdated func(childComplexity int) int+ FlowUpdated func(childComplexity int) int+ KnowledgeDocumentCreated func(childComplexity int) int+ KnowledgeDocumentDeleted func(childComplexity int) int+ KnowledgeDocumentUpdated func(childComplexity int) int+ MessageLogAdded func(childComplexity int, flowID int64) int+ MessageLogUpdated func(childComplexity int, flowID int64) int+ ProviderCreated func(childComplexity int) int+ ProviderDeleted func(childComplexity int) int+ ProviderUpdated func(childComplexity int) int+ ResourceAdded func(childComplexity int) int+ ResourceDeleted func(childComplexity int) int+ ResourceUpdated func(childComplexity int) int+ ScreenshotAdded func(childComplexity int, flowID int64) int+ SearchLogAdded func(childComplexity int, flowID int64) int+ SettingsUserUpdated func(childComplexity int) int+ TaskCreated func(childComplexity int, flowID int64) int+ TaskUpdated func(childComplexity int, flowID int64) int+ TerminalLogAdded func(childComplexity int, flowID int64) int+ VectorStoreLogAdded func(childComplexity int, flowID int64) int}Subtask struct {@@ -709,6 +741,9 @@ type MutationResolver interface {CreateFlowTemplate(ctx context.Context, input model.CreateFlowTemplateInput) (*model.FlowTemplate, error)UpdateFlowTemplate(ctx context.Context, templateID int64, input model.UpdateFlowTemplateInput) (*model.FlowTemplate, error)DeleteFlowTemplate(ctx context.Context, templateID int64) (model.ResultType, error)+ CreateKnowledgeDocument(ctx context.Context, input model.CreateKnowledgeDocumentInput) (*model.KnowledgeDocument, error)+ UpdateKnowledgeDocument(ctx context.Context, id string, input model.UpdateKnowledgeDocumentInput) (*model.KnowledgeDocument, error)+ DeleteKnowledgeDocument(ctx context.Context, id string) (model.ResultType, error)}type QueryResolver interface {Providers(ctx context.Context) ([]*model.Provider, error)@@ -750,6 +785,9 @@ type QueryResolver interface {FlowTemplate(ctx context.Context, templateID int64) (*model.FlowTemplate, error)FlowTemplates(ctx context.Context) ([]*model.FlowTemplate, error)Resources(ctx context.Context, path *string, recursive *bool) ([]*model.UserResource, error)+ KnowledgeDocuments(ctx context.Context, filter *model.KnowledgeFilter, withContent bool) ([]*model.KnowledgeDocument, error)+ KnowledgeDocument(ctx context.Context, id string) (*model.KnowledgeDocument, error)+ SearchKnowledge(ctx context.Context, query string, filter *model.KnowledgeFilter, limit *int) ([]*model.KnowledgeDocumentWithScore, error)}type SubscriptionResolver interface {FlowCreated(ctx context.Context) (<-chan *model.Flow, error)@@ -785,6 +823,9 @@ type SubscriptionResolver interface {ResourceAdded(ctx context.Context) (<-chan *model.UserResource, error)ResourceUpdated(ctx context.Context) (<-chan *model.UserResource, error)ResourceDeleted(ctx context.Context) (<-chan *model.UserResource, error)+ KnowledgeDocumentCreated(ctx context.Context) (<-chan *model.KnowledgeDocument, error)+ KnowledgeDocumentUpdated(ctx context.Context) (<-chan *model.KnowledgeDocument, error)+ KnowledgeDocumentDeleted(ctx context.Context) (<-chan *model.KnowledgeDocument, error)}type executableSchema struct {@@ -1870,6 +1911,125 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity inreturn e.complexity.FunctionToolcallsStats.TotalDurationSeconds(childComplexity), true+ case "KnowledgeDocument.answerType":+ if e.complexity.KnowledgeDocument.AnswerType == nil {+ break+ }++ return e.complexity.KnowledgeDocument.AnswerType(childComplexity), true++ case "KnowledgeDocument.codeLang":+ if e.complexity.KnowledgeDocument.CodeLang == nil {+ break+ }++ return e.complexity.KnowledgeDocument.CodeLang(childComplexity), true++ case "KnowledgeDocument.content":+ if e.complexity.KnowledgeDocument.Content == nil {+ break+ }++ return e.complexity.KnowledgeDocument.Content(childComplexity), true++ case "KnowledgeDocument.description":+ if e.complexity.KnowledgeDocument.Description == nil {+ break+ }++ return e.complexity.KnowledgeDocument.Description(childComplexity), true++ case "KnowledgeDocument.docType":+ if e.complexity.KnowledgeDocument.DocType == nil {+ break+ }++ return e.complexity.KnowledgeDocument.DocType(childComplexity), true++ case "KnowledgeDocument.flowId":+ if e.complexity.KnowledgeDocument.FlowID == nil {+ break+ }++ return e.complexity.KnowledgeDocument.FlowID(childComplexity), true++ case "KnowledgeDocument.guideType":+ if e.complexity.KnowledgeDocument.GuideType == nil {+ break+ }++ return e.complexity.KnowledgeDocument.GuideType(childComplexity), true++ case "KnowledgeDocument.id":+ if e.complexity.KnowledgeDocument.ID == nil {+ break+ }++ return e.complexity.KnowledgeDocument.ID(childComplexity), true++ case "KnowledgeDocument.manual":+ if e.complexity.KnowledgeDocument.Manual == nil {+ break+ }++ return e.complexity.KnowledgeDocument.Manual(childComplexity), true++ case "KnowledgeDocument.partSize":+ if e.complexity.KnowledgeDocument.PartSize == nil {+ break+ }++ return e.complexity.KnowledgeDocument.PartSize(childComplexity), true++ case "KnowledgeDocument.question":+ if e.complexity.KnowledgeDocument.Question == nil {+ break+ }++ return e.complexity.KnowledgeDocument.Question(childComplexity), true++ case "KnowledgeDocument.subtaskId":+ if e.complexity.KnowledgeDocument.SubtaskID == nil {+ break+ }++ return e.complexity.KnowledgeDocument.SubtaskID(childComplexity), true++ case "KnowledgeDocument.taskId":+ if e.complexity.KnowledgeDocument.TaskID == nil {+ break+ }++ return e.complexity.KnowledgeDocument.TaskID(childComplexity), true++ case "KnowledgeDocument.totalSize":+ if e.complexity.KnowledgeDocument.TotalSize == nil {+ break+ }++ return e.complexity.KnowledgeDocument.TotalSize(childComplexity), true++ case "KnowledgeDocument.userId":+ if e.complexity.KnowledgeDocument.UserID == nil {+ break+ }++ return e.complexity.KnowledgeDocument.UserID(childComplexity), true++ case "KnowledgeDocumentWithScore.document":+ if e.complexity.KnowledgeDocumentWithScore.Document == nil {+ break+ }++ return e.complexity.KnowledgeDocumentWithScore.Document(childComplexity), true++ case "KnowledgeDocumentWithScore.score":+ if e.complexity.KnowledgeDocumentWithScore.Score == nil {+ break+ }++ return e.complexity.KnowledgeDocumentWithScore.Score(childComplexity), true+case "MessageLog.createdAt":if e.complexity.MessageLog.CreatedAt == nil {break@@ -2124,6 +2284,18 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity inreturn e.complexity.Mutation.CreateFlowTemplate(childComplexity, args["input"].(model.CreateFlowTemplateInput)), true+ case "Mutation.createKnowledgeDocument":+ if e.complexity.Mutation.CreateKnowledgeDocument == nil {+ break+ }++ args, err := ec.field_Mutation_createKnowledgeDocument_args(context.TODO(), rawArgs)+ if err != nil {+ return 0, false+ }++ return e.complexity.Mutation.CreateKnowledgeDocument(childComplexity, args["input"].(model.CreateKnowledgeDocumentInput)), true+case "Mutation.createPrompt":if e.complexity.Mutation.CreatePrompt == nil {break@@ -2208,6 +2380,18 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity inreturn e.complexity.Mutation.DeleteFlowTemplate(childComplexity, args["templateId"].(int64)), true+ case "Mutation.deleteKnowledgeDocument":+ if e.complexity.Mutation.DeleteKnowledgeDocument == nil {+ break+ }++ args, err := ec.field_Mutation_deleteKnowledgeDocument_args(context.TODO(), rawArgs)+ if err != nil {+ return 0, false+ }++ return e.complexity.Mutation.DeleteKnowledgeDocument(childComplexity, args["id"].(string)), true+case "Mutation.deletePrompt":if e.complexity.Mutation.DeletePrompt == nil {break@@ -2340,6 +2524,18 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity inreturn e.complexity.Mutation.UpdateFlowTemplate(childComplexity, args["templateId"].(int64), args["input"].(model.UpdateFlowTemplateInput)), true+ case "Mutation.updateKnowledgeDocument":+ if e.complexity.Mutation.UpdateKnowledgeDocument == nil {+ break+ }++ args, err := ec.field_Mutation_updateKnowledgeDocument_args(context.TODO(), rawArgs)+ if err != nil {+ return 0, false+ }++ return e.complexity.Mutation.UpdateKnowledgeDocument(childComplexity, args["id"].(string), args["input"].(model.UpdateKnowledgeDocumentInput)), true+case "Mutation.updatePrompt":if e.complexity.Mutation.UpdatePrompt == nil {break@@ -2902,6 +3098,30 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity inreturn e.complexity.Query.FlowsStatsTotal(childComplexity), true+ case "Query.knowledgeDocument":+ if e.complexity.Query.KnowledgeDocument == nil {+ break+ }++ args, err := ec.field_Query_knowledgeDocument_args(context.TODO(), rawArgs)+ if err != nil {+ return 0, false+ }++ return e.complexity.Query.KnowledgeDocument(childComplexity, args["id"].(string)), true++ case "Query.knowledgeDocuments":+ if e.complexity.Query.KnowledgeDocuments == nil {+ break+ }++ args, err := ec.field_Query_knowledgeDocuments_args(context.TODO(), rawArgs)+ if err != nil {+ return 0, false+ }++ return e.complexity.Query.KnowledgeDocuments(childComplexity, args["filter"].(*model.KnowledgeFilter), args["withContent"].(bool)), true+case "Query.messageLogs":if e.complexity.Query.MessageLogs == nil {break@@ -2945,6 +3165,18 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity inreturn e.complexity.Query.Screenshots(childComplexity, args["flowId"].(int64)), true+ case "Query.searchKnowledge":+ if e.complexity.Query.SearchKnowledge == nil {+ break+ }++ args, err := ec.field_Query_searchKnowledge_args(context.TODO(), rawArgs)+ if err != nil {+ return 0, false+ }++ return e.complexity.Query.SearchKnowledge(childComplexity, args["query"].(string), args["filter"].(*model.KnowledgeFilter), args["limit"].(*int)), true+case "Query.searchLogs":if e.complexity.Query.SearchLogs == nil {break@@ -3479,6 +3711,27 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity inreturn e.complexity.Subscription.FlowUpdated(childComplexity), true+ case "Subscription.knowledgeDocumentCreated":+ if e.complexity.Subscription.KnowledgeDocumentCreated == nil {+ break+ }++ return e.complexity.Subscription.KnowledgeDocumentCreated(childComplexity), true++ case "Subscription.knowledgeDocumentDeleted":+ if e.complexity.Subscription.KnowledgeDocumentDeleted == nil {+ break+ }++ return e.complexity.Subscription.KnowledgeDocumentDeleted(childComplexity), true++ case "Subscription.knowledgeDocumentUpdated":+ if e.complexity.Subscription.KnowledgeDocumentUpdated == nil {+ break+ }++ return e.complexity.Subscription.KnowledgeDocumentUpdated(childComplexity), true+case "Subscription.messageLogAdded":if e.complexity.Subscription.MessageLogAdded == nil {break@@ -4287,10 +4540,13 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {ec.unmarshalInputAgentsConfigInput,ec.unmarshalInputCreateAPITokenInput,ec.unmarshalInputCreateFlowTemplateInput,+ ec.unmarshalInputCreateKnowledgeDocumentInput,+ ec.unmarshalInputKnowledgeFilter,ec.unmarshalInputModelPriceInput,ec.unmarshalInputReasoningConfigInput,ec.unmarshalInputUpdateAPITokenInput,ec.unmarshalInputUpdateFlowTemplateInput,+ ec.unmarshalInputUpdateKnowledgeDocumentInput,)first := true@@ -4886,6 +5142,38 @@ func (ec *executionContext) field_Mutation_createFlow_argsResourceIds(return zeroVal, nil}+func (ec *executionContext) field_Mutation_createKnowledgeDocument_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+ var err error+ args := map[string]interface{}{}+ arg0, err := ec.field_Mutation_createKnowledgeDocument_argsInput(ctx, rawArgs)+ if err != nil {+ return nil, err+ }+ args["input"] = arg0+ return args, nil+}+func (ec *executionContext) field_Mutation_createKnowledgeDocument_argsInput(+ ctx context.Context,+ rawArgs map[string]interface{},+) (model.CreateKnowledgeDocumentInput, error) {+ // We won't call the directive if the argument is null.+ // Set call_argument_directives_with_null to true to call directives+ // even if the argument is null.+ _, ok := rawArgs["input"]+ if !ok {+ var zeroVal model.CreateKnowledgeDocumentInput+ return zeroVal, nil+ }++ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))+ if tmp, ok := rawArgs["input"]; ok {+ return ec.unmarshalNCreateKnowledgeDocumentInput2pentagiᚋpkgᚋgraphᚋmodelᚐCreateKnowledgeDocumentInput(ctx, tmp)+ }++ var zeroVal model.CreateKnowledgeDocumentInput+ return zeroVal, nil+}+func (ec *executionContext) field_Mutation_createPrompt_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}@@ -5218,6 +5506,38 @@ func (ec *executionContext) field_Mutation_deleteFlow_argsFlowID(return zeroVal, nil}+func (ec *executionContext) field_Mutation_deleteKnowledgeDocument_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+ var err error+ args := map[string]interface{}{}+ arg0, err := ec.field_Mutation_deleteKnowledgeDocument_argsID(ctx, rawArgs)+ if err != nil {+ return nil, err+ }+ args["id"] = arg0+ return args, nil+}+func (ec *executionContext) field_Mutation_deleteKnowledgeDocument_argsID(+ ctx context.Context,+ rawArgs map[string]interface{},+) (string, error) {+ // We won't call the directive if the argument is null.+ // Set call_argument_directives_with_null to true to call directives+ // even if the argument is null.+ _, ok := rawArgs["id"]+ if !ok {+ var zeroVal string+ return zeroVal, nil+ }++ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))+ if tmp, ok := rawArgs["id"]; ok {+ return ec.unmarshalNString2string(ctx, tmp)+ }++ var zeroVal string+ return zeroVal, nil+}+func (ec *executionContext) field_Mutation_deletePrompt_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}@@ -5840,6 +6160,65 @@ func (ec *executionContext) field_Mutation_updateFlowTemplate_argsInput(return zeroVal, nil}+func (ec *executionContext) field_Mutation_updateKnowledgeDocument_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+ var err error+ args := map[string]interface{}{}+ arg0, err := ec.field_Mutation_updateKnowledgeDocument_argsID(ctx, rawArgs)+ if err != nil {+ return nil, err+ }+ args["id"] = arg0+ arg1, err := ec.field_Mutation_updateKnowledgeDocument_argsInput(ctx, rawArgs)+ if err != nil {+ return nil, err+ }+ args["input"] = arg1+ return args, nil+}+func (ec *executionContext) field_Mutation_updateKnowledgeDocument_argsID(+ ctx context.Context,+ rawArgs map[string]interface{},+) (string, error) {+ // We won't call the directive if the argument is null.+ // Set call_argument_directives_with_null to true to call directives+ // even if the argument is null.+ _, ok := rawArgs["id"]+ if !ok {+ var zeroVal string+ return zeroVal, nil+ }++ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))+ if tmp, ok := rawArgs["id"]; ok {+ return ec.unmarshalNString2string(ctx, tmp)+ }++ var zeroVal string+ return zeroVal, nil+}++func (ec *executionContext) field_Mutation_updateKnowledgeDocument_argsInput(+ ctx context.Context,+ rawArgs map[string]interface{},+) (model.UpdateKnowledgeDocumentInput, error) {+ // We won't call the directive if the argument is null.+ // Set call_argument_directives_with_null to true to call directives+ // even if the argument is null.+ _, ok := rawArgs["input"]+ if !ok {+ var zeroVal model.UpdateKnowledgeDocumentInput+ return zeroVal, nil+ }++ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))+ if tmp, ok := rawArgs["input"]; ok {+ return ec.unmarshalNUpdateKnowledgeDocumentInput2pentagiᚋpkgᚋgraphᚋmodelᚐUpdateKnowledgeDocumentInput(ctx, tmp)+ }++ var zeroVal model.UpdateKnowledgeDocumentInput+ return zeroVal, nil+}+func (ec *executionContext) field_Mutation_updatePrompt_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}@@ -6423,108 +6802,108 @@ func (ec *executionContext) field_Query_flowsStatsByPeriod_argsPeriod(return zeroVal, nil}-func (ec *executionContext) field_Query_messageLogs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Query_knowledgeDocument_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Query_messageLogs_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Query_knowledgeDocument_argsID(ctx, rawArgs)if err != nil {return nil, err}- args["flowId"] = arg0+ args["id"] = arg0return args, nil}-func (ec *executionContext) field_Query_messageLogs_argsFlowID(+func (ec *executionContext) field_Query_knowledgeDocument_argsID(ctx context.Context,rawArgs map[string]interface{},-) (int64, error) {+) (string, error) {// We won't call the directive if the argument is null.// Set call_argument_directives_with_null to true to call directives// even if the argument is null.- _, ok := rawArgs["flowId"]+ _, ok := rawArgs["id"]if !ok {- var zeroVal int64+ var zeroVal stringreturn zeroVal, nil}- ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId"))- if tmp, ok := rawArgs["flowId"]; ok {- return ec.unmarshalNID2int64(ctx, tmp)+ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))+ if tmp, ok := rawArgs["id"]; ok {+ return ec.unmarshalNString2string(ctx, tmp)}- var zeroVal int64+ var zeroVal stringreturn zeroVal, nil}-func (ec *executionContext) field_Query_resources_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Query_knowledgeDocuments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Query_resources_argsPath(ctx, rawArgs)+ arg0, err := ec.field_Query_knowledgeDocuments_argsFilter(ctx, rawArgs)if err != nil {return nil, err}- args["path"] = arg0- arg1, err := ec.field_Query_resources_argsRecursive(ctx, rawArgs)+ args["filter"] = arg0+ arg1, err := ec.field_Query_knowledgeDocuments_argsWithContent(ctx, rawArgs)if err != nil {return nil, err}- args["recursive"] = arg1+ args["withContent"] = arg1return args, nil}-func (ec *executionContext) field_Query_resources_argsPath(+func (ec *executionContext) field_Query_knowledgeDocuments_argsFilter(ctx context.Context,rawArgs map[string]interface{},-) (*string, error) {+) (*model.KnowledgeFilter, error) {// We won't call the directive if the argument is null.// Set call_argument_directives_with_null to true to call directives// even if the argument is null.- _, ok := rawArgs["path"]+ _, ok := rawArgs["filter"]if !ok {- var zeroVal *string+ var zeroVal *model.KnowledgeFilterreturn zeroVal, nil}- ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("path"))- if tmp, ok := rawArgs["path"]; ok {- return ec.unmarshalOString2ᚖstring(ctx, tmp)+ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))+ if tmp, ok := rawArgs["filter"]; ok {+ return ec.unmarshalOKnowledgeFilter2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeFilter(ctx, tmp)}- var zeroVal *string+ var zeroVal *model.KnowledgeFilterreturn zeroVal, nil}-func (ec *executionContext) field_Query_resources_argsRecursive(+func (ec *executionContext) field_Query_knowledgeDocuments_argsWithContent(ctx context.Context,rawArgs map[string]interface{},-) (*bool, error) {+) (bool, error) {// We won't call the directive if the argument is null.// Set call_argument_directives_with_null to true to call directives// even if the argument is null.- _, ok := rawArgs["recursive"]+ _, ok := rawArgs["withContent"]if !ok {- var zeroVal *bool+ var zeroVal boolreturn zeroVal, nil}- ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("recursive"))- if tmp, ok := rawArgs["recursive"]; ok {- return ec.unmarshalOBoolean2ᚖbool(ctx, tmp)+ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("withContent"))+ if tmp, ok := rawArgs["withContent"]; ok {+ return ec.unmarshalNBoolean2bool(ctx, tmp)}- var zeroVal *bool+ var zeroVal boolreturn zeroVal, nil}-func (ec *executionContext) field_Query_screenshots_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Query_messageLogs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Query_screenshots_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Query_messageLogs_argsFlowID(ctx, rawArgs)if err != nil {return nil, err}args["flowId"] = arg0return args, nil}-func (ec *executionContext) field_Query_screenshots_argsFlowID(+func (ec *executionContext) field_Query_messageLogs_argsFlowID(ctx context.Context,rawArgs map[string]interface{},) (int64, error) {@@ -6546,49 +6925,76 @@ func (ec *executionContext) field_Query_screenshots_argsFlowID(return zeroVal, nil}-func (ec *executionContext) field_Query_searchLogs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Query_resources_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Query_searchLogs_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Query_resources_argsPath(ctx, rawArgs)if err != nil {return nil, err}- args["flowId"] = arg0+ args["path"] = arg0+ arg1, err := ec.field_Query_resources_argsRecursive(ctx, rawArgs)+ if err != nil {+ return nil, err+ }+ args["recursive"] = arg1return args, nil}-func (ec *executionContext) field_Query_searchLogs_argsFlowID(+func (ec *executionContext) field_Query_resources_argsPath(ctx context.Context,rawArgs map[string]interface{},-) (int64, error) {+) (*string, error) {// We won't call the directive if the argument is null.// Set call_argument_directives_with_null to true to call directives// even if the argument is null.- _, ok := rawArgs["flowId"]+ _, ok := rawArgs["path"]if !ok {- var zeroVal int64+ var zeroVal *stringreturn zeroVal, nil}- ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId"))- if tmp, ok := rawArgs["flowId"]; ok {- return ec.unmarshalNID2int64(ctx, tmp)+ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("path"))+ if tmp, ok := rawArgs["path"]; ok {+ return ec.unmarshalOString2ᚖstring(ctx, tmp)}- var zeroVal int64+ var zeroVal *stringreturn zeroVal, nil}-func (ec *executionContext) field_Query_tasks_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Query_resources_argsRecursive(+ ctx context.Context,+ rawArgs map[string]interface{},+) (*bool, error) {+ // We won't call the directive if the argument is null.+ // Set call_argument_directives_with_null to true to call directives+ // even if the argument is null.+ _, ok := rawArgs["recursive"]+ if !ok {+ var zeroVal *bool+ return zeroVal, nil+ }++ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("recursive"))+ if tmp, ok := rawArgs["recursive"]; ok {+ return ec.unmarshalOBoolean2ᚖbool(ctx, tmp)+ }++ var zeroVal *bool+ return zeroVal, nil+}++func (ec *executionContext) field_Query_screenshots_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Query_tasks_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Query_screenshots_argsFlowID(ctx, rawArgs)if err != nil {return nil, err}args["flowId"] = arg0return args, nil}-func (ec *executionContext) field_Query_tasks_argsFlowID(+func (ec *executionContext) field_Query_screenshots_argsFlowID(ctx context.Context,rawArgs map[string]interface{},) (int64, error) {@@ -6610,81 +7016,103 @@ func (ec *executionContext) field_Query_tasks_argsFlowID(return zeroVal, nil}-func (ec *executionContext) field_Query_terminalLogs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Query_searchKnowledge_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Query_terminalLogs_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Query_searchKnowledge_argsQuery(ctx, rawArgs)if err != nil {return nil, err}- args["flowId"] = arg0+ args["query"] = arg0+ arg1, err := ec.field_Query_searchKnowledge_argsFilter(ctx, rawArgs)+ if err != nil {+ return nil, err+ }+ args["filter"] = arg1+ arg2, err := ec.field_Query_searchKnowledge_argsLimit(ctx, rawArgs)+ if err != nil {+ return nil, err+ }+ args["limit"] = arg2return args, nil}-func (ec *executionContext) field_Query_terminalLogs_argsFlowID(+func (ec *executionContext) field_Query_searchKnowledge_argsQuery(ctx context.Context,rawArgs map[string]interface{},-) (int64, error) {+) (string, error) {// We won't call the directive if the argument is null.// Set call_argument_directives_with_null to true to call directives// even if the argument is null.- _, ok := rawArgs["flowId"]+ _, ok := rawArgs["query"]if !ok {- var zeroVal int64+ var zeroVal stringreturn zeroVal, nil}- ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId"))- if tmp, ok := rawArgs["flowId"]; ok {- return ec.unmarshalNID2int64(ctx, tmp)+ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query"))+ if tmp, ok := rawArgs["query"]; ok {+ return ec.unmarshalNString2string(ctx, tmp)}- var zeroVal int64+ var zeroVal stringreturn zeroVal, nil}-func (ec *executionContext) field_Query_toolcallsStatsByFlow_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {- var err error- args := map[string]interface{}{}- arg0, err := ec.field_Query_toolcallsStatsByFlow_argsFlowID(ctx, rawArgs)- if err != nil {- return nil, err+func (ec *executionContext) field_Query_searchKnowledge_argsFilter(+ ctx context.Context,+ rawArgs map[string]interface{},+) (*model.KnowledgeFilter, error) {+ // We won't call the directive if the argument is null.+ // Set call_argument_directives_with_null to true to call directives+ // even if the argument is null.+ _, ok := rawArgs["filter"]+ if !ok {+ var zeroVal *model.KnowledgeFilter+ return zeroVal, nil}- args["flowId"] = arg0- return args, nil++ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))+ if tmp, ok := rawArgs["filter"]; ok {+ return ec.unmarshalOKnowledgeFilter2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeFilter(ctx, tmp)+ }++ var zeroVal *model.KnowledgeFilter+ return zeroVal, nil}-func (ec *executionContext) field_Query_toolcallsStatsByFlow_argsFlowID(++func (ec *executionContext) field_Query_searchKnowledge_argsLimit(ctx context.Context,rawArgs map[string]interface{},-) (int64, error) {+) (*int, error) {// We won't call the directive if the argument is null.// Set call_argument_directives_with_null to true to call directives// even if the argument is null.- _, ok := rawArgs["flowId"]+ _, ok := rawArgs["limit"]if !ok {- var zeroVal int64+ var zeroVal *intreturn zeroVal, nil}- ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId"))- if tmp, ok := rawArgs["flowId"]; ok {- return ec.unmarshalNID2int64(ctx, tmp)+ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))+ if tmp, ok := rawArgs["limit"]; ok {+ return ec.unmarshalOInt2ᚖint(ctx, tmp)}- var zeroVal int64+ var zeroVal *intreturn zeroVal, nil}-func (ec *executionContext) field_Query_toolcallsStatsByFunctionForFlow_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Query_searchLogs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Query_toolcallsStatsByFunctionForFlow_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Query_searchLogs_argsFlowID(ctx, rawArgs)if err != nil {return nil, err}args["flowId"] = arg0return args, nil}-func (ec *executionContext) field_Query_toolcallsStatsByFunctionForFlow_argsFlowID(+func (ec *executionContext) field_Query_searchLogs_argsFlowID(ctx context.Context,rawArgs map[string]interface{},) (int64, error) {@@ -6706,49 +7134,49 @@ func (ec *executionContext) field_Query_toolcallsStatsByFunctionForFlow_argsFlowreturn zeroVal, nil}-func (ec *executionContext) field_Query_toolcallsStatsByPeriod_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Query_tasks_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Query_toolcallsStatsByPeriod_argsPeriod(ctx, rawArgs)+ arg0, err := ec.field_Query_tasks_argsFlowID(ctx, rawArgs)if err != nil {return nil, err}- args["period"] = arg0+ args["flowId"] = arg0return args, nil}-func (ec *executionContext) field_Query_toolcallsStatsByPeriod_argsPeriod(+func (ec *executionContext) field_Query_tasks_argsFlowID(ctx context.Context,rawArgs map[string]interface{},-) (model.UsageStatsPeriod, error) {+) (int64, error) {// We won't call the directive if the argument is null.// Set call_argument_directives_with_null to true to call directives// even if the argument is null.- _, ok := rawArgs["period"]+ _, ok := rawArgs["flowId"]if !ok {- var zeroVal model.UsageStatsPeriod+ var zeroVal int64return zeroVal, nil}- ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("period"))- if tmp, ok := rawArgs["period"]; ok {- return ec.unmarshalNUsageStatsPeriod2pentagiᚋpkgᚋgraphᚋmodelᚐUsageStatsPeriod(ctx, tmp)+ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId"))+ if tmp, ok := rawArgs["flowId"]; ok {+ return ec.unmarshalNID2int64(ctx, tmp)}- var zeroVal model.UsageStatsPeriod+ var zeroVal int64return zeroVal, nil}-func (ec *executionContext) field_Query_usageStatsByAgentTypeForFlow_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Query_terminalLogs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Query_usageStatsByAgentTypeForFlow_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Query_terminalLogs_argsFlowID(ctx, rawArgs)if err != nil {return nil, err}args["flowId"] = arg0return args, nil}-func (ec *executionContext) field_Query_usageStatsByAgentTypeForFlow_argsFlowID(+func (ec *executionContext) field_Query_terminalLogs_argsFlowID(ctx context.Context,rawArgs map[string]interface{},) (int64, error) {@@ -6770,17 +7198,17 @@ func (ec *executionContext) field_Query_usageStatsByAgentTypeForFlow_argsFlowID(return zeroVal, nil}-func (ec *executionContext) field_Query_usageStatsByFlow_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Query_toolcallsStatsByFlow_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Query_usageStatsByFlow_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Query_toolcallsStatsByFlow_argsFlowID(ctx, rawArgs)if err != nil {return nil, err}args["flowId"] = arg0return args, nil}-func (ec *executionContext) field_Query_usageStatsByFlow_argsFlowID(+func (ec *executionContext) field_Query_toolcallsStatsByFlow_argsFlowID(ctx context.Context,rawArgs map[string]interface{},) (int64, error) {@@ -6802,17 +7230,17 @@ func (ec *executionContext) field_Query_usageStatsByFlow_argsFlowID(return zeroVal, nil}-func (ec *executionContext) field_Query_usageStatsByModelAgentsForFlow_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Query_toolcallsStatsByFunctionForFlow_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Query_usageStatsByModelAgentsForFlow_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Query_toolcallsStatsByFunctionForFlow_argsFlowID(ctx, rawArgs)if err != nil {return nil, err}args["flowId"] = arg0return args, nil}-func (ec *executionContext) field_Query_usageStatsByModelAgentsForFlow_argsFlowID(+func (ec *executionContext) field_Query_toolcallsStatsByFunctionForFlow_argsFlowID(ctx context.Context,rawArgs map[string]interface{},) (int64, error) {@@ -6834,17 +7262,17 @@ func (ec *executionContext) field_Query_usageStatsByModelAgentsForFlow_argsFlowIreturn zeroVal, nil}-func (ec *executionContext) field_Query_usageStatsByPeriod_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Query_toolcallsStatsByPeriod_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Query_usageStatsByPeriod_argsPeriod(ctx, rawArgs)+ arg0, err := ec.field_Query_toolcallsStatsByPeriod_argsPeriod(ctx, rawArgs)if err != nil {return nil, err}args["period"] = arg0return args, nil}-func (ec *executionContext) field_Query_usageStatsByPeriod_argsPeriod(+func (ec *executionContext) field_Query_toolcallsStatsByPeriod_argsPeriod(ctx context.Context,rawArgs map[string]interface{},) (model.UsageStatsPeriod, error) {@@ -6866,49 +7294,17 @@ func (ec *executionContext) field_Query_usageStatsByPeriod_argsPeriod(return zeroVal, nil}-func (ec *executionContext) field_Query_vectorStoreLogs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {- var err error- args := map[string]interface{}{}- arg0, err := ec.field_Query_vectorStoreLogs_argsFlowID(ctx, rawArgs)- if err != nil {- return nil, err- }- args["flowId"] = arg0- return args, nil-}-func (ec *executionContext) field_Query_vectorStoreLogs_argsFlowID(- ctx context.Context,- rawArgs map[string]interface{},-) (int64, error) {- // We won't call the directive if the argument is null.- // Set call_argument_directives_with_null to true to call directives- // even if the argument is null.- _, ok := rawArgs["flowId"]- if !ok {- var zeroVal int64- return zeroVal, nil- }-- ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId"))- if tmp, ok := rawArgs["flowId"]; ok {- return ec.unmarshalNID2int64(ctx, tmp)- }-- var zeroVal int64- return zeroVal, nil-}--func (ec *executionContext) field_Subscription_agentLogAdded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Query_usageStatsByAgentTypeForFlow_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Subscription_agentLogAdded_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Query_usageStatsByAgentTypeForFlow_argsFlowID(ctx, rawArgs)if err != nil {return nil, err}args["flowId"] = arg0return args, nil}-func (ec *executionContext) field_Subscription_agentLogAdded_argsFlowID(+func (ec *executionContext) field_Query_usageStatsByAgentTypeForFlow_argsFlowID(ctx context.Context,rawArgs map[string]interface{},) (int64, error) {@@ -6930,17 +7326,17 @@ func (ec *executionContext) field_Subscription_agentLogAdded_argsFlowID(return zeroVal, nil}-func (ec *executionContext) field_Subscription_assistantCreated_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Query_usageStatsByFlow_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Subscription_assistantCreated_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Query_usageStatsByFlow_argsFlowID(ctx, rawArgs)if err != nil {return nil, err}args["flowId"] = arg0return args, nil}-func (ec *executionContext) field_Subscription_assistantCreated_argsFlowID(+func (ec *executionContext) field_Query_usageStatsByFlow_argsFlowID(ctx context.Context,rawArgs map[string]interface{},) (int64, error) {@@ -6962,17 +7358,17 @@ func (ec *executionContext) field_Subscription_assistantCreated_argsFlowID(return zeroVal, nil}-func (ec *executionContext) field_Subscription_assistantDeleted_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Query_usageStatsByModelAgentsForFlow_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Subscription_assistantDeleted_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Query_usageStatsByModelAgentsForFlow_argsFlowID(ctx, rawArgs)if err != nil {return nil, err}args["flowId"] = arg0return args, nil}-func (ec *executionContext) field_Subscription_assistantDeleted_argsFlowID(+func (ec *executionContext) field_Query_usageStatsByModelAgentsForFlow_argsFlowID(ctx context.Context,rawArgs map[string]interface{},) (int64, error) {@@ -6994,49 +7390,49 @@ func (ec *executionContext) field_Subscription_assistantDeleted_argsFlowID(return zeroVal, nil}-func (ec *executionContext) field_Subscription_assistantLogAdded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Query_usageStatsByPeriod_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Subscription_assistantLogAdded_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Query_usageStatsByPeriod_argsPeriod(ctx, rawArgs)if err != nil {return nil, err}- args["flowId"] = arg0+ args["period"] = arg0return args, nil}-func (ec *executionContext) field_Subscription_assistantLogAdded_argsFlowID(+func (ec *executionContext) field_Query_usageStatsByPeriod_argsPeriod(ctx context.Context,rawArgs map[string]interface{},-) (int64, error) {+) (model.UsageStatsPeriod, error) {// We won't call the directive if the argument is null.// Set call_argument_directives_with_null to true to call directives// even if the argument is null.- _, ok := rawArgs["flowId"]+ _, ok := rawArgs["period"]if !ok {- var zeroVal int64+ var zeroVal model.UsageStatsPeriodreturn zeroVal, nil}- ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId"))- if tmp, ok := rawArgs["flowId"]; ok {- return ec.unmarshalNID2int64(ctx, tmp)+ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("period"))+ if tmp, ok := rawArgs["period"]; ok {+ return ec.unmarshalNUsageStatsPeriod2pentagiᚋpkgᚋgraphᚋmodelᚐUsageStatsPeriod(ctx, tmp)}- var zeroVal int64+ var zeroVal model.UsageStatsPeriodreturn zeroVal, nil}-func (ec *executionContext) field_Subscription_assistantLogUpdated_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Query_vectorStoreLogs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Subscription_assistantLogUpdated_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Query_vectorStoreLogs_argsFlowID(ctx, rawArgs)if err != nil {return nil, err}args["flowId"] = arg0return args, nil}-func (ec *executionContext) field_Subscription_assistantLogUpdated_argsFlowID(+func (ec *executionContext) field_Query_vectorStoreLogs_argsFlowID(ctx context.Context,rawArgs map[string]interface{},) (int64, error) {@@ -7058,17 +7454,17 @@ func (ec *executionContext) field_Subscription_assistantLogUpdated_argsFlowID(return zeroVal, nil}-func (ec *executionContext) field_Subscription_assistantUpdated_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Subscription_agentLogAdded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Subscription_assistantUpdated_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Subscription_agentLogAdded_argsFlowID(ctx, rawArgs)if err != nil {return nil, err}args["flowId"] = arg0return args, nil}-func (ec *executionContext) field_Subscription_assistantUpdated_argsFlowID(+func (ec *executionContext) field_Subscription_agentLogAdded_argsFlowID(ctx context.Context,rawArgs map[string]interface{},) (int64, error) {@@ -7090,17 +7486,17 @@ func (ec *executionContext) field_Subscription_assistantUpdated_argsFlowID(return zeroVal, nil}-func (ec *executionContext) field_Subscription_flowFileAdded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Subscription_assistantCreated_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Subscription_flowFileAdded_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Subscription_assistantCreated_argsFlowID(ctx, rawArgs)if err != nil {return nil, err}args["flowId"] = arg0return args, nil}-func (ec *executionContext) field_Subscription_flowFileAdded_argsFlowID(+func (ec *executionContext) field_Subscription_assistantCreated_argsFlowID(ctx context.Context,rawArgs map[string]interface{},) (int64, error) {@@ -7122,17 +7518,17 @@ func (ec *executionContext) field_Subscription_flowFileAdded_argsFlowID(return zeroVal, nil}-func (ec *executionContext) field_Subscription_flowFileDeleted_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Subscription_assistantDeleted_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Subscription_flowFileDeleted_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Subscription_assistantDeleted_argsFlowID(ctx, rawArgs)if err != nil {return nil, err}args["flowId"] = arg0return args, nil}-func (ec *executionContext) field_Subscription_flowFileDeleted_argsFlowID(+func (ec *executionContext) field_Subscription_assistantDeleted_argsFlowID(ctx context.Context,rawArgs map[string]interface{},) (int64, error) {@@ -7154,17 +7550,177 @@ func (ec *executionContext) field_Subscription_flowFileDeleted_argsFlowID(return zeroVal, nil}-func (ec *executionContext) field_Subscription_flowFileUpdated_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+func (ec *executionContext) field_Subscription_assistantLogAdded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {var err errorargs := map[string]interface{}{}- arg0, err := ec.field_Subscription_flowFileUpdated_argsFlowID(ctx, rawArgs)+ arg0, err := ec.field_Subscription_assistantLogAdded_argsFlowID(ctx, rawArgs)if err != nil {return nil, err}args["flowId"] = arg0return args, nil}-func (ec *executionContext) field_Subscription_flowFileUpdated_argsFlowID(+func (ec *executionContext) field_Subscription_assistantLogAdded_argsFlowID(+ ctx context.Context,+ rawArgs map[string]interface{},+) (int64, error) {+ // We won't call the directive if the argument is null.+ // Set call_argument_directives_with_null to true to call directives+ // even if the argument is null.+ _, ok := rawArgs["flowId"]+ if !ok {+ var zeroVal int64+ return zeroVal, nil+ }++ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId"))+ if tmp, ok := rawArgs["flowId"]; ok {+ return ec.unmarshalNID2int64(ctx, tmp)+ }++ var zeroVal int64+ return zeroVal, nil+}++func (ec *executionContext) field_Subscription_assistantLogUpdated_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+ var err error+ args := map[string]interface{}{}+ arg0, err := ec.field_Subscription_assistantLogUpdated_argsFlowID(ctx, rawArgs)+ if err != nil {+ return nil, err+ }+ args["flowId"] = arg0+ return args, nil+}+func (ec *executionContext) field_Subscription_assistantLogUpdated_argsFlowID(+ ctx context.Context,+ rawArgs map[string]interface{},+) (int64, error) {+ // We won't call the directive if the argument is null.+ // Set call_argument_directives_with_null to true to call directives+ // even if the argument is null.+ _, ok := rawArgs["flowId"]+ if !ok {+ var zeroVal int64+ return zeroVal, nil+ }++ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId"))+ if tmp, ok := rawArgs["flowId"]; ok {+ return ec.unmarshalNID2int64(ctx, tmp)+ }++ var zeroVal int64+ return zeroVal, nil+}++func (ec *executionContext) field_Subscription_assistantUpdated_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+ var err error+ args := map[string]interface{}{}+ arg0, err := ec.field_Subscription_assistantUpdated_argsFlowID(ctx, rawArgs)+ if err != nil {+ return nil, err+ }+ args["flowId"] = arg0+ return args, nil+}+func (ec *executionContext) field_Subscription_assistantUpdated_argsFlowID(+ ctx context.Context,+ rawArgs map[string]interface{},+) (int64, error) {+ // We won't call the directive if the argument is null.+ // Set call_argument_directives_with_null to true to call directives+ // even if the argument is null.+ _, ok := rawArgs["flowId"]+ if !ok {+ var zeroVal int64+ return zeroVal, nil+ }++ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId"))+ if tmp, ok := rawArgs["flowId"]; ok {+ return ec.unmarshalNID2int64(ctx, tmp)+ }++ var zeroVal int64+ return zeroVal, nil+}++func (ec *executionContext) field_Subscription_flowFileAdded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+ var err error+ args := map[string]interface{}{}+ arg0, err := ec.field_Subscription_flowFileAdded_argsFlowID(ctx, rawArgs)+ if err != nil {+ return nil, err+ }+ args["flowId"] = arg0+ return args, nil+}+func (ec *executionContext) field_Subscription_flowFileAdded_argsFlowID(+ ctx context.Context,+ rawArgs map[string]interface{},+) (int64, error) {+ // We won't call the directive if the argument is null.+ // Set call_argument_directives_with_null to true to call directives+ // even if the argument is null.+ _, ok := rawArgs["flowId"]+ if !ok {+ var zeroVal int64+ return zeroVal, nil+ }++ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId"))+ if tmp, ok := rawArgs["flowId"]; ok {+ return ec.unmarshalNID2int64(ctx, tmp)+ }++ var zeroVal int64+ return zeroVal, nil+}++func (ec *executionContext) field_Subscription_flowFileDeleted_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+ var err error+ args := map[string]interface{}{}+ arg0, err := ec.field_Subscription_flowFileDeleted_argsFlowID(ctx, rawArgs)+ if err != nil {+ return nil, err+ }+ args["flowId"] = arg0+ return args, nil+}+func (ec *executionContext) field_Subscription_flowFileDeleted_argsFlowID(+ ctx context.Context,+ rawArgs map[string]interface{},+) (int64, error) {+ // We won't call the directive if the argument is null.+ // Set call_argument_directives_with_null to true to call directives+ // even if the argument is null.+ _, ok := rawArgs["flowId"]+ if !ok {+ var zeroVal int64+ return zeroVal, nil+ }++ ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId"))+ if tmp, ok := rawArgs["flowId"]; ok {+ return ec.unmarshalNID2int64(ctx, tmp)+ }++ var zeroVal int64+ return zeroVal, nil+}++func (ec *executionContext) field_Subscription_flowFileUpdated_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {+ var err error+ args := map[string]interface{}{}+ arg0, err := ec.field_Subscription_flowFileUpdated_argsFlowID(ctx, rawArgs)+ if err != nil {+ return nil, err+ }+ args["flowId"] = arg0+ return args, nil+}+func (ec *executionContext) field_Subscription_flowFileUpdated_argsFlowID(ctx context.Context,rawArgs map[string]interface{},) (int64, error) {@@ -14334,9 +14890,842 @@ func (ec *executionContext) _FlowTemplate_userId(ctx context.Context, field grapreturn ec.marshalNID2int64(ctx, field.Selections, res)}-func (ec *executionContext) fieldContext_FlowTemplate_userId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_FlowTemplate_userId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "FlowTemplate",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type ID does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _FlowTemplate_title(ctx context.Context, field graphql.CollectedField, obj *model.FlowTemplate) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_FlowTemplate_title(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.Title, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(string)+ fc.Result = res+ return ec.marshalNString2string(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_FlowTemplate_title(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "FlowTemplate",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type String does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _FlowTemplate_text(ctx context.Context, field graphql.CollectedField, obj *model.FlowTemplate) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_FlowTemplate_text(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.Text, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(string)+ fc.Result = res+ return ec.marshalNString2string(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_FlowTemplate_text(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "FlowTemplate",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type String does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _FlowTemplate_createdAt(ctx context.Context, field graphql.CollectedField, obj *model.FlowTemplate) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_FlowTemplate_createdAt(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.CreatedAt, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(time.Time)+ fc.Result = res+ return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_FlowTemplate_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "FlowTemplate",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type Time does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _FlowTemplate_updatedAt(ctx context.Context, field graphql.CollectedField, obj *model.FlowTemplate) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_FlowTemplate_updatedAt(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.UpdatedAt, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(time.Time)+ fc.Result = res+ return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_FlowTemplate_updatedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "FlowTemplate",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type Time does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _FlowsStats_totalFlowsCount(ctx context.Context, field graphql.CollectedField, obj *model.FlowsStats) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_FlowsStats_totalFlowsCount(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.TotalFlowsCount, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(int)+ fc.Result = res+ return ec.marshalNInt2int(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_FlowsStats_totalFlowsCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "FlowsStats",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type Int does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _FlowsStats_totalTasksCount(ctx context.Context, field graphql.CollectedField, obj *model.FlowsStats) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_FlowsStats_totalTasksCount(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.TotalTasksCount, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(int)+ fc.Result = res+ return ec.marshalNInt2int(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_FlowsStats_totalTasksCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "FlowsStats",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type Int does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _FlowsStats_totalSubtasksCount(ctx context.Context, field graphql.CollectedField, obj *model.FlowsStats) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_FlowsStats_totalSubtasksCount(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.TotalSubtasksCount, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(int)+ fc.Result = res+ return ec.marshalNInt2int(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_FlowsStats_totalSubtasksCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "FlowsStats",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type Int does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _FlowsStats_totalAssistantsCount(ctx context.Context, field graphql.CollectedField, obj *model.FlowsStats) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_FlowsStats_totalAssistantsCount(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.TotalAssistantsCount, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(int)+ fc.Result = res+ return ec.marshalNInt2int(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_FlowsStats_totalAssistantsCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "FlowsStats",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type Int does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _FunctionToolcallsStats_functionName(ctx context.Context, field graphql.CollectedField, obj *model.FunctionToolcallsStats) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_FunctionToolcallsStats_functionName(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.FunctionName, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(string)+ fc.Result = res+ return ec.marshalNString2string(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_FunctionToolcallsStats_functionName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "FunctionToolcallsStats",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type String does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _FunctionToolcallsStats_isAgent(ctx context.Context, field graphql.CollectedField, obj *model.FunctionToolcallsStats) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_FunctionToolcallsStats_isAgent(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.IsAgent, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(bool)+ fc.Result = res+ return ec.marshalNBoolean2bool(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_FunctionToolcallsStats_isAgent(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "FunctionToolcallsStats",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type Boolean does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _FunctionToolcallsStats_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.FunctionToolcallsStats) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_FunctionToolcallsStats_totalCount(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.TotalCount, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(int)+ fc.Result = res+ return ec.marshalNInt2int(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_FunctionToolcallsStats_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "FunctionToolcallsStats",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type Int does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _FunctionToolcallsStats_totalDurationSeconds(ctx context.Context, field graphql.CollectedField, obj *model.FunctionToolcallsStats) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_FunctionToolcallsStats_totalDurationSeconds(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.TotalDurationSeconds, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(float64)+ fc.Result = res+ return ec.marshalNFloat2float64(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_FunctionToolcallsStats_totalDurationSeconds(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "FunctionToolcallsStats",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type Float does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _FunctionToolcallsStats_avgDurationSeconds(ctx context.Context, field graphql.CollectedField, obj *model.FunctionToolcallsStats) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_FunctionToolcallsStats_avgDurationSeconds(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.AvgDurationSeconds, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(float64)+ fc.Result = res+ return ec.marshalNFloat2float64(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_FunctionToolcallsStats_avgDurationSeconds(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "FunctionToolcallsStats",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type Float does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _KnowledgeDocument_id(ctx context.Context, field graphql.CollectedField, obj *model.KnowledgeDocument) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_KnowledgeDocument_id(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.ID, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(string)+ fc.Result = res+ return ec.marshalNString2string(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_KnowledgeDocument_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "KnowledgeDocument",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type String does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _KnowledgeDocument_docType(ctx context.Context, field graphql.CollectedField, obj *model.KnowledgeDocument) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_KnowledgeDocument_docType(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.DocType, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(model.KnowledgeDocType)+ fc.Result = res+ return ec.marshalNKnowledgeDocType2pentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocType(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_KnowledgeDocument_docType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "KnowledgeDocument",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type KnowledgeDocType does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _KnowledgeDocument_content(ctx context.Context, field graphql.CollectedField, obj *model.KnowledgeDocument) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_KnowledgeDocument_content(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.Content, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(string)+ fc.Result = res+ return ec.marshalNString2string(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_KnowledgeDocument_content(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "KnowledgeDocument",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type String does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _KnowledgeDocument_question(ctx context.Context, field graphql.CollectedField, obj *model.KnowledgeDocument) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_KnowledgeDocument_question(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.Question, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(string)+ fc.Result = res+ return ec.marshalNString2string(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_KnowledgeDocument_question(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "KnowledgeDocument",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type String does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _KnowledgeDocument_description(ctx context.Context, field graphql.CollectedField, obj *model.KnowledgeDocument) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_KnowledgeDocument_description(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.Description, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ return graphql.Null+ }+ res := resTmp.(*string)+ fc.Result = res+ return ec.marshalOString2ᚖstring(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_KnowledgeDocument_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "KnowledgeDocument",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type String does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _KnowledgeDocument_userId(ctx context.Context, field graphql.CollectedField, obj *model.KnowledgeDocument) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_KnowledgeDocument_userId(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return obj.UserID, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(int64)+ fc.Result = res+ return ec.marshalNID2int64(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_KnowledgeDocument_userId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{- Object: "FlowTemplate",+ Object: "KnowledgeDocument",Field: field,IsMethod: false,IsResolver: false,@@ -14347,8 +15736,8 @@ func (ec *executionContext) fieldContext_FlowTemplate_userId(_ context.Context,return fc, nil}-func (ec *executionContext) _FlowTemplate_title(ctx context.Context, field graphql.CollectedField, obj *model.FlowTemplate) (ret graphql.Marshaler) {- fc, err := ec.fieldContext_FlowTemplate_title(ctx, field)+func (ec *executionContext) _KnowledgeDocument_flowId(ctx context.Context, field graphql.CollectedField, obj *model.KnowledgeDocument) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_KnowledgeDocument_flowId(ctx, field)if err != nil {return graphql.Null}@@ -14361,38 +15750,35 @@ func (ec *executionContext) _FlowTemplate_title(ctx context.Context, field graph}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return obj.Title, nil+ return obj.FlowID, nil})if err != nil {ec.Error(ctx, err)return graphql.Null}if resTmp == nil {- if !graphql.HasFieldError(ctx, fc) {- ec.Errorf(ctx, "must not be null")- }return graphql.Null}- res := resTmp.(string)+ res := resTmp.(*int64)fc.Result = res- return ec.marshalNString2string(ctx, field.Selections, res)+ return ec.marshalOID2ᚖint64(ctx, field.Selections, res)}-func (ec *executionContext) fieldContext_FlowTemplate_title(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_KnowledgeDocument_flowId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{- Object: "FlowTemplate",+ Object: "KnowledgeDocument",Field: field,IsMethod: false,IsResolver: false,Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {- return nil, errors.New("field of type String does not have child fields")+ return nil, errors.New("field of type ID does not have child fields")},}return fc, nil}-func (ec *executionContext) _FlowTemplate_text(ctx context.Context, field graphql.CollectedField, obj *model.FlowTemplate) (ret graphql.Marshaler) {- fc, err := ec.fieldContext_FlowTemplate_text(ctx, field)+func (ec *executionContext) _KnowledgeDocument_taskId(ctx context.Context, field graphql.CollectedField, obj *model.KnowledgeDocument) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_KnowledgeDocument_taskId(ctx, field)if err != nil {return graphql.Null}@@ -14405,38 +15791,35 @@ func (ec *executionContext) _FlowTemplate_text(ctx context.Context, field graphq}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return obj.Text, nil+ return obj.TaskID, nil})if err != nil {ec.Error(ctx, err)return graphql.Null}if resTmp == nil {- if !graphql.HasFieldError(ctx, fc) {- ec.Errorf(ctx, "must not be null")- }return graphql.Null}- res := resTmp.(string)+ res := resTmp.(*int64)fc.Result = res- return ec.marshalNString2string(ctx, field.Selections, res)+ return ec.marshalOID2ᚖint64(ctx, field.Selections, res)}-func (ec *executionContext) fieldContext_FlowTemplate_text(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_KnowledgeDocument_taskId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{- Object: "FlowTemplate",+ Object: "KnowledgeDocument",Field: field,IsMethod: false,IsResolver: false,Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {- return nil, errors.New("field of type String does not have child fields")+ return nil, errors.New("field of type ID does not have child fields")},}return fc, nil}-func (ec *executionContext) _FlowTemplate_createdAt(ctx context.Context, field graphql.CollectedField, obj *model.FlowTemplate) (ret graphql.Marshaler) {- fc, err := ec.fieldContext_FlowTemplate_createdAt(ctx, field)+func (ec *executionContext) _KnowledgeDocument_subtaskId(ctx context.Context, field graphql.CollectedField, obj *model.KnowledgeDocument) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_KnowledgeDocument_subtaskId(ctx, field)if err != nil {return graphql.Null}@@ -14449,38 +15832,35 @@ func (ec *executionContext) _FlowTemplate_createdAt(ctx context.Context, field g}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return obj.CreatedAt, nil+ return obj.SubtaskID, nil})if err != nil {ec.Error(ctx, err)return graphql.Null}if resTmp == nil {- if !graphql.HasFieldError(ctx, fc) {- ec.Errorf(ctx, "must not be null")- }return graphql.Null}- res := resTmp.(time.Time)+ res := resTmp.(*int64)fc.Result = res- return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)+ return ec.marshalOID2ᚖint64(ctx, field.Selections, res)}-func (ec *executionContext) fieldContext_FlowTemplate_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_KnowledgeDocument_subtaskId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{- Object: "FlowTemplate",+ Object: "KnowledgeDocument",Field: field,IsMethod: false,IsResolver: false,Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {- return nil, errors.New("field of type Time does not have child fields")+ return nil, errors.New("field of type ID does not have child fields")},}return fc, nil}-func (ec *executionContext) _FlowTemplate_updatedAt(ctx context.Context, field graphql.CollectedField, obj *model.FlowTemplate) (ret graphql.Marshaler) {- fc, err := ec.fieldContext_FlowTemplate_updatedAt(ctx, field)+func (ec *executionContext) _KnowledgeDocument_guideType(ctx context.Context, field graphql.CollectedField, obj *model.KnowledgeDocument) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_KnowledgeDocument_guideType(ctx, field)if err != nil {return graphql.Null}@@ -14493,38 +15873,35 @@ func (ec *executionContext) _FlowTemplate_updatedAt(ctx context.Context, field g}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return obj.UpdatedAt, nil+ return obj.GuideType, nil})if err != nil {ec.Error(ctx, err)return graphql.Null}if resTmp == nil {- if !graphql.HasFieldError(ctx, fc) {- ec.Errorf(ctx, "must not be null")- }return graphql.Null}- res := resTmp.(time.Time)+ res := resTmp.(*model.KnowledgeGuideType)fc.Result = res- return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)+ return ec.marshalOKnowledgeGuideType2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeGuideType(ctx, field.Selections, res)}-func (ec *executionContext) fieldContext_FlowTemplate_updatedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_KnowledgeDocument_guideType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{- Object: "FlowTemplate",+ Object: "KnowledgeDocument",Field: field,IsMethod: false,IsResolver: false,Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {- return nil, errors.New("field of type Time does not have child fields")+ return nil, errors.New("field of type KnowledgeGuideType does not have child fields")},}return fc, nil}-func (ec *executionContext) _FlowsStats_totalFlowsCount(ctx context.Context, field graphql.CollectedField, obj *model.FlowsStats) (ret graphql.Marshaler) {- fc, err := ec.fieldContext_FlowsStats_totalFlowsCount(ctx, field)+func (ec *executionContext) _KnowledgeDocument_answerType(ctx context.Context, field graphql.CollectedField, obj *model.KnowledgeDocument) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_KnowledgeDocument_answerType(ctx, field)if err != nil {return graphql.Null}@@ -14537,38 +15914,35 @@ func (ec *executionContext) _FlowsStats_totalFlowsCount(ctx context.Context, fie}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return obj.TotalFlowsCount, nil+ return obj.AnswerType, nil})if err != nil {ec.Error(ctx, err)return graphql.Null}if resTmp == nil {- if !graphql.HasFieldError(ctx, fc) {- ec.Errorf(ctx, "must not be null")- }return graphql.Null}- res := resTmp.(int)+ res := resTmp.(*model.KnowledgeAnswerType)fc.Result = res- return ec.marshalNInt2int(ctx, field.Selections, res)+ return ec.marshalOKnowledgeAnswerType2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeAnswerType(ctx, field.Selections, res)}-func (ec *executionContext) fieldContext_FlowsStats_totalFlowsCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_KnowledgeDocument_answerType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{- Object: "FlowsStats",+ Object: "KnowledgeDocument",Field: field,IsMethod: false,IsResolver: false,Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {- return nil, errors.New("field of type Int does not have child fields")+ return nil, errors.New("field of type KnowledgeAnswerType does not have child fields")},}return fc, nil}-func (ec *executionContext) _FlowsStats_totalTasksCount(ctx context.Context, field graphql.CollectedField, obj *model.FlowsStats) (ret graphql.Marshaler) {- fc, err := ec.fieldContext_FlowsStats_totalTasksCount(ctx, field)+func (ec *executionContext) _KnowledgeDocument_codeLang(ctx context.Context, field graphql.CollectedField, obj *model.KnowledgeDocument) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_KnowledgeDocument_codeLang(ctx, field)if err != nil {return graphql.Null}@@ -14581,38 +15955,35 @@ func (ec *executionContext) _FlowsStats_totalTasksCount(ctx context.Context, fie}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return obj.TotalTasksCount, nil+ return obj.CodeLang, nil})if err != nil {ec.Error(ctx, err)return graphql.Null}if resTmp == nil {- if !graphql.HasFieldError(ctx, fc) {- ec.Errorf(ctx, "must not be null")- }return graphql.Null}- res := resTmp.(int)+ res := resTmp.(*string)fc.Result = res- return ec.marshalNInt2int(ctx, field.Selections, res)+ return ec.marshalOString2ᚖstring(ctx, field.Selections, res)}-func (ec *executionContext) fieldContext_FlowsStats_totalTasksCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_KnowledgeDocument_codeLang(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{- Object: "FlowsStats",+ Object: "KnowledgeDocument",Field: field,IsMethod: false,IsResolver: false,Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {- return nil, errors.New("field of type Int does not have child fields")+ return nil, errors.New("field of type String does not have child fields")},}return fc, nil}-func (ec *executionContext) _FlowsStats_totalSubtasksCount(ctx context.Context, field graphql.CollectedField, obj *model.FlowsStats) (ret graphql.Marshaler) {- fc, err := ec.fieldContext_FlowsStats_totalSubtasksCount(ctx, field)+func (ec *executionContext) _KnowledgeDocument_partSize(ctx context.Context, field graphql.CollectedField, obj *model.KnowledgeDocument) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_KnowledgeDocument_partSize(ctx, field)if err != nil {return graphql.Null}@@ -14625,7 +15996,7 @@ func (ec *executionContext) _FlowsStats_totalSubtasksCount(ctx context.Context,}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return obj.TotalSubtasksCount, nil+ return obj.PartSize, nil})if err != nil {ec.Error(ctx, err)@@ -14642,9 +16013,9 @@ func (ec *executionContext) _FlowsStats_totalSubtasksCount(ctx context.Context,return ec.marshalNInt2int(ctx, field.Selections, res)}-func (ec *executionContext) fieldContext_FlowsStats_totalSubtasksCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_KnowledgeDocument_partSize(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{- Object: "FlowsStats",+ Object: "KnowledgeDocument",Field: field,IsMethod: false,IsResolver: false,@@ -14655,8 +16026,8 @@ func (ec *executionContext) fieldContext_FlowsStats_totalSubtasksCount(_ contextreturn fc, nil}-func (ec *executionContext) _FlowsStats_totalAssistantsCount(ctx context.Context, field graphql.CollectedField, obj *model.FlowsStats) (ret graphql.Marshaler) {- fc, err := ec.fieldContext_FlowsStats_totalAssistantsCount(ctx, field)+func (ec *executionContext) _KnowledgeDocument_totalSize(ctx context.Context, field graphql.CollectedField, obj *model.KnowledgeDocument) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_KnowledgeDocument_totalSize(ctx, field)if err != nil {return graphql.Null}@@ -14669,7 +16040,7 @@ func (ec *executionContext) _FlowsStats_totalAssistantsCount(ctx context.Context}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return obj.TotalAssistantsCount, nil+ return obj.TotalSize, nil})if err != nil {ec.Error(ctx, err)@@ -14686,9 +16057,9 @@ func (ec *executionContext) _FlowsStats_totalAssistantsCount(ctx context.Contextreturn ec.marshalNInt2int(ctx, field.Selections, res)}-func (ec *executionContext) fieldContext_FlowsStats_totalAssistantsCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_KnowledgeDocument_totalSize(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{- Object: "FlowsStats",+ Object: "KnowledgeDocument",Field: field,IsMethod: false,IsResolver: false,@@ -14699,52 +16070,8 @@ func (ec *executionContext) fieldContext_FlowsStats_totalAssistantsCount(_ contereturn fc, nil}-func (ec *executionContext) _FunctionToolcallsStats_functionName(ctx context.Context, field graphql.CollectedField, obj *model.FunctionToolcallsStats) (ret graphql.Marshaler) {- fc, err := ec.fieldContext_FunctionToolcallsStats_functionName(ctx, field)- if err != nil {- return graphql.Null- }- ctx = graphql.WithFieldContext(ctx, fc)- defer func() {- if r := recover(); r != nil {- ec.Error(ctx, ec.Recover(ctx, r))- ret = graphql.Null- }- }()- resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {- ctx = rctx // use context from middleware stack in children- return obj.FunctionName, nil- })- if err != nil {- ec.Error(ctx, err)- return graphql.Null- }- if resTmp == nil {- if !graphql.HasFieldError(ctx, fc) {- ec.Errorf(ctx, "must not be null")- }- return graphql.Null- }- res := resTmp.(string)- fc.Result = res- return ec.marshalNString2string(ctx, field.Selections, res)-}--func (ec *executionContext) fieldContext_FunctionToolcallsStats_functionName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {- fc = &graphql.FieldContext{- Object: "FunctionToolcallsStats",- Field: field,- IsMethod: false,- IsResolver: false,- Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {- return nil, errors.New("field of type String does not have child fields")- },- }- return fc, nil-}--func (ec *executionContext) _FunctionToolcallsStats_isAgent(ctx context.Context, field graphql.CollectedField, obj *model.FunctionToolcallsStats) (ret graphql.Marshaler) {- fc, err := ec.fieldContext_FunctionToolcallsStats_isAgent(ctx, field)+func (ec *executionContext) _KnowledgeDocument_manual(ctx context.Context, field graphql.CollectedField, obj *model.KnowledgeDocument) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_KnowledgeDocument_manual(ctx, field)if err != nil {return graphql.Null}@@ -14757,7 +16084,7 @@ func (ec *executionContext) _FunctionToolcallsStats_isAgent(ctx context.Context,}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return obj.IsAgent, nil+ return obj.Manual, nil})if err != nil {ec.Error(ctx, err)@@ -14774,9 +16101,9 @@ func (ec *executionContext) _FunctionToolcallsStats_isAgent(ctx context.Context,return ec.marshalNBoolean2bool(ctx, field.Selections, res)}-func (ec *executionContext) fieldContext_FunctionToolcallsStats_isAgent(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_KnowledgeDocument_manual(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{- Object: "FunctionToolcallsStats",+ Object: "KnowledgeDocument",Field: field,IsMethod: false,IsResolver: false,@@ -14787,8 +16114,8 @@ func (ec *executionContext) fieldContext_FunctionToolcallsStats_isAgent(_ contexreturn fc, nil}-func (ec *executionContext) _FunctionToolcallsStats_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.FunctionToolcallsStats) (ret graphql.Marshaler) {- fc, err := ec.fieldContext_FunctionToolcallsStats_totalCount(ctx, field)+func (ec *executionContext) _KnowledgeDocumentWithScore_score(ctx context.Context, field graphql.CollectedField, obj *model.KnowledgeDocumentWithScore) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_KnowledgeDocumentWithScore_score(ctx, field)if err != nil {return graphql.Null}@@ -14801,51 +16128,7 @@ func (ec *executionContext) _FunctionToolcallsStats_totalCount(ctx context.Conte}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return obj.TotalCount, nil- })- if err != nil {- ec.Error(ctx, err)- return graphql.Null- }- if resTmp == nil {- if !graphql.HasFieldError(ctx, fc) {- ec.Errorf(ctx, "must not be null")- }- return graphql.Null- }- res := resTmp.(int)- fc.Result = res- return ec.marshalNInt2int(ctx, field.Selections, res)-}--func (ec *executionContext) fieldContext_FunctionToolcallsStats_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {- fc = &graphql.FieldContext{- Object: "FunctionToolcallsStats",- Field: field,- IsMethod: false,- IsResolver: false,- Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {- return nil, errors.New("field of type Int does not have child fields")- },- }- return fc, nil-}--func (ec *executionContext) _FunctionToolcallsStats_totalDurationSeconds(ctx context.Context, field graphql.CollectedField, obj *model.FunctionToolcallsStats) (ret graphql.Marshaler) {- fc, err := ec.fieldContext_FunctionToolcallsStats_totalDurationSeconds(ctx, field)- if err != nil {- return graphql.Null- }- ctx = graphql.WithFieldContext(ctx, fc)- defer func() {- if r := recover(); r != nil {- ec.Error(ctx, ec.Recover(ctx, r))- ret = graphql.Null- }- }()- resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {- ctx = rctx // use context from middleware stack in children- return obj.TotalDurationSeconds, nil+ return obj.Score, nil})if err != nil {ec.Error(ctx, err)@@ -14862,9 +16145,9 @@ func (ec *executionContext) _FunctionToolcallsStats_totalDurationSeconds(ctx conreturn ec.marshalNFloat2float64(ctx, field.Selections, res)}-func (ec *executionContext) fieldContext_FunctionToolcallsStats_totalDurationSeconds(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_KnowledgeDocumentWithScore_score(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{- Object: "FunctionToolcallsStats",+ Object: "KnowledgeDocumentWithScore",Field: field,IsMethod: false,IsResolver: false,@@ -14875,8 +16158,8 @@ func (ec *executionContext) fieldContext_FunctionToolcallsStats_totalDurationSecreturn fc, nil}-func (ec *executionContext) _FunctionToolcallsStats_avgDurationSeconds(ctx context.Context, field graphql.CollectedField, obj *model.FunctionToolcallsStats) (ret graphql.Marshaler) {- fc, err := ec.fieldContext_FunctionToolcallsStats_avgDurationSeconds(ctx, field)+func (ec *executionContext) _KnowledgeDocumentWithScore_document(ctx context.Context, field graphql.CollectedField, obj *model.KnowledgeDocumentWithScore) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_KnowledgeDocumentWithScore_document(ctx, field)if err != nil {return graphql.Null}@@ -14889,7 +16172,7 @@ func (ec *executionContext) _FunctionToolcallsStats_avgDurationSeconds(ctx conte}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return obj.AvgDurationSeconds, nil+ return obj.Document, nil})if err != nil {ec.Error(ctx, err)@@ -14901,19 +16184,51 @@ func (ec *executionContext) _FunctionToolcallsStats_avgDurationSeconds(ctx conte}return graphql.Null}- res := resTmp.(float64)+ res := resTmp.(*model.KnowledgeDocument)fc.Result = res- return ec.marshalNFloat2float64(ctx, field.Selections, res)+ return ec.marshalNKnowledgeDocument2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocument(ctx, field.Selections, res)}-func (ec *executionContext) fieldContext_FunctionToolcallsStats_avgDurationSeconds(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_KnowledgeDocumentWithScore_document(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{- Object: "FunctionToolcallsStats",+ Object: "KnowledgeDocumentWithScore",Field: field,IsMethod: false,IsResolver: false,Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {- return nil, errors.New("field of type Float does not have child fields")+ switch field.Name {+ case "id":+ return ec.fieldContext_KnowledgeDocument_id(ctx, field)+ case "docType":+ return ec.fieldContext_KnowledgeDocument_docType(ctx, field)+ case "content":+ return ec.fieldContext_KnowledgeDocument_content(ctx, field)+ case "question":+ return ec.fieldContext_KnowledgeDocument_question(ctx, field)+ case "description":+ return ec.fieldContext_KnowledgeDocument_description(ctx, field)+ case "userId":+ return ec.fieldContext_KnowledgeDocument_userId(ctx, field)+ case "flowId":+ return ec.fieldContext_KnowledgeDocument_flowId(ctx, field)+ case "taskId":+ return ec.fieldContext_KnowledgeDocument_taskId(ctx, field)+ case "subtaskId":+ return ec.fieldContext_KnowledgeDocument_subtaskId(ctx, field)+ case "guideType":+ return ec.fieldContext_KnowledgeDocument_guideType(ctx, field)+ case "answerType":+ return ec.fieldContext_KnowledgeDocument_answerType(ctx, field)+ case "codeLang":+ return ec.fieldContext_KnowledgeDocument_codeLang(ctx, field)+ case "partSize":+ return ec.fieldContext_KnowledgeDocument_partSize(ctx, field)+ case "totalSize":+ return ec.fieldContext_KnowledgeDocument_totalSize(ctx, field)+ case "manual":+ return ec.fieldContext_KnowledgeDocument_manual(ctx, field)+ }+ return nil, fmt.Errorf("no field named %q was found under type KnowledgeDocument", field.Name)},}return fc, nil@@ -17771,6 +19086,235 @@ func (ec *executionContext) fieldContext_Mutation_deleteFlowTemplate(ctx contextreturn fc, nil}+func (ec *executionContext) _Mutation_createKnowledgeDocument(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_Mutation_createKnowledgeDocument(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return ec.resolvers.Mutation().CreateKnowledgeDocument(rctx, fc.Args["input"].(model.CreateKnowledgeDocumentInput))+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(*model.KnowledgeDocument)+ fc.Result = res+ return ec.marshalNKnowledgeDocument2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocument(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_Mutation_createKnowledgeDocument(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "Mutation",+ Field: field,+ IsMethod: true,+ IsResolver: true,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ switch field.Name {+ case "id":+ return ec.fieldContext_KnowledgeDocument_id(ctx, field)+ case "docType":+ return ec.fieldContext_KnowledgeDocument_docType(ctx, field)+ case "content":+ return ec.fieldContext_KnowledgeDocument_content(ctx, field)+ case "question":+ return ec.fieldContext_KnowledgeDocument_question(ctx, field)+ case "description":+ return ec.fieldContext_KnowledgeDocument_description(ctx, field)+ case "userId":+ return ec.fieldContext_KnowledgeDocument_userId(ctx, field)+ case "flowId":+ return ec.fieldContext_KnowledgeDocument_flowId(ctx, field)+ case "taskId":+ return ec.fieldContext_KnowledgeDocument_taskId(ctx, field)+ case "subtaskId":+ return ec.fieldContext_KnowledgeDocument_subtaskId(ctx, field)+ case "guideType":+ return ec.fieldContext_KnowledgeDocument_guideType(ctx, field)+ case "answerType":+ return ec.fieldContext_KnowledgeDocument_answerType(ctx, field)+ case "codeLang":+ return ec.fieldContext_KnowledgeDocument_codeLang(ctx, field)+ case "partSize":+ return ec.fieldContext_KnowledgeDocument_partSize(ctx, field)+ case "totalSize":+ return ec.fieldContext_KnowledgeDocument_totalSize(ctx, field)+ case "manual":+ return ec.fieldContext_KnowledgeDocument_manual(ctx, field)+ }+ return nil, fmt.Errorf("no field named %q was found under type KnowledgeDocument", field.Name)+ },+ }+ defer func() {+ if r := recover(); r != nil {+ err = ec.Recover(ctx, r)+ ec.Error(ctx, err)+ }+ }()+ ctx = graphql.WithFieldContext(ctx, fc)+ if fc.Args, err = ec.field_Mutation_createKnowledgeDocument_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {+ ec.Error(ctx, err)+ return fc, err+ }+ return fc, nil+}++func (ec *executionContext) _Mutation_updateKnowledgeDocument(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_Mutation_updateKnowledgeDocument(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return ec.resolvers.Mutation().UpdateKnowledgeDocument(rctx, fc.Args["id"].(string), fc.Args["input"].(model.UpdateKnowledgeDocumentInput))+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(*model.KnowledgeDocument)+ fc.Result = res+ return ec.marshalNKnowledgeDocument2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocument(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_Mutation_updateKnowledgeDocument(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "Mutation",+ Field: field,+ IsMethod: true,+ IsResolver: true,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ switch field.Name {+ case "id":+ return ec.fieldContext_KnowledgeDocument_id(ctx, field)+ case "docType":+ return ec.fieldContext_KnowledgeDocument_docType(ctx, field)+ case "content":+ return ec.fieldContext_KnowledgeDocument_content(ctx, field)+ case "question":+ return ec.fieldContext_KnowledgeDocument_question(ctx, field)+ case "description":+ return ec.fieldContext_KnowledgeDocument_description(ctx, field)+ case "userId":+ return ec.fieldContext_KnowledgeDocument_userId(ctx, field)+ case "flowId":+ return ec.fieldContext_KnowledgeDocument_flowId(ctx, field)+ case "taskId":+ return ec.fieldContext_KnowledgeDocument_taskId(ctx, field)+ case "subtaskId":+ return ec.fieldContext_KnowledgeDocument_subtaskId(ctx, field)+ case "guideType":+ return ec.fieldContext_KnowledgeDocument_guideType(ctx, field)+ case "answerType":+ return ec.fieldContext_KnowledgeDocument_answerType(ctx, field)+ case "codeLang":+ return ec.fieldContext_KnowledgeDocument_codeLang(ctx, field)+ case "partSize":+ return ec.fieldContext_KnowledgeDocument_partSize(ctx, field)+ case "totalSize":+ return ec.fieldContext_KnowledgeDocument_totalSize(ctx, field)+ case "manual":+ return ec.fieldContext_KnowledgeDocument_manual(ctx, field)+ }+ return nil, fmt.Errorf("no field named %q was found under type KnowledgeDocument", field.Name)+ },+ }+ defer func() {+ if r := recover(); r != nil {+ err = ec.Recover(ctx, r)+ ec.Error(ctx, err)+ }+ }()+ ctx = graphql.WithFieldContext(ctx, fc)+ if fc.Args, err = ec.field_Mutation_updateKnowledgeDocument_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {+ ec.Error(ctx, err)+ return fc, err+ }+ return fc, nil+}++func (ec *executionContext) _Mutation_deleteKnowledgeDocument(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_Mutation_deleteKnowledgeDocument(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return ec.resolvers.Mutation().DeleteKnowledgeDocument(rctx, fc.Args["id"].(string))+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(model.ResultType)+ fc.Result = res+ return ec.marshalNResultType2pentagiᚋpkgᚋgraphᚋmodelᚐResultType(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_Mutation_deleteKnowledgeDocument(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "Mutation",+ Field: field,+ IsMethod: true,+ IsResolver: true,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type ResultType does not have child fields")+ },+ }+ defer func() {+ if r := recover(); r != nil {+ err = ec.Recover(ctx, r)+ ec.Error(ctx, err)+ }+ }()+ ctx = graphql.WithFieldContext(ctx, fc)+ if fc.Args, err = ec.field_Mutation_deleteKnowledgeDocument_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {+ ec.Error(ctx, err)+ return fc, err+ }+ return fc, nil+}+func (ec *executionContext) _PromptValidationResult_result(ctx context.Context, field graphql.CollectedField, obj *model.PromptValidationResult) (ret graphql.Marshaler) {fc, err := ec.fieldContext_PromptValidationResult_result(ctx, field)if err != nil {@@ -22866,6 +24410,241 @@ func (ec *executionContext) fieldContext_Query_resources(ctx context.Context, fireturn fc, nil}+func (ec *executionContext) _Query_knowledgeDocuments(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_Query_knowledgeDocuments(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return ec.resolvers.Query().KnowledgeDocuments(rctx, fc.Args["filter"].(*model.KnowledgeFilter), fc.Args["withContent"].(bool))+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.([]*model.KnowledgeDocument)+ fc.Result = res+ return ec.marshalNKnowledgeDocument2ᚕᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocumentᚄ(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_Query_knowledgeDocuments(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "Query",+ Field: field,+ IsMethod: true,+ IsResolver: true,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ switch field.Name {+ case "id":+ return ec.fieldContext_KnowledgeDocument_id(ctx, field)+ case "docType":+ return ec.fieldContext_KnowledgeDocument_docType(ctx, field)+ case "content":+ return ec.fieldContext_KnowledgeDocument_content(ctx, field)+ case "question":+ return ec.fieldContext_KnowledgeDocument_question(ctx, field)+ case "description":+ return ec.fieldContext_KnowledgeDocument_description(ctx, field)+ case "userId":+ return ec.fieldContext_KnowledgeDocument_userId(ctx, field)+ case "flowId":+ return ec.fieldContext_KnowledgeDocument_flowId(ctx, field)+ case "taskId":+ return ec.fieldContext_KnowledgeDocument_taskId(ctx, field)+ case "subtaskId":+ return ec.fieldContext_KnowledgeDocument_subtaskId(ctx, field)+ case "guideType":+ return ec.fieldContext_KnowledgeDocument_guideType(ctx, field)+ case "answerType":+ return ec.fieldContext_KnowledgeDocument_answerType(ctx, field)+ case "codeLang":+ return ec.fieldContext_KnowledgeDocument_codeLang(ctx, field)+ case "partSize":+ return ec.fieldContext_KnowledgeDocument_partSize(ctx, field)+ case "totalSize":+ return ec.fieldContext_KnowledgeDocument_totalSize(ctx, field)+ case "manual":+ return ec.fieldContext_KnowledgeDocument_manual(ctx, field)+ }+ return nil, fmt.Errorf("no field named %q was found under type KnowledgeDocument", field.Name)+ },+ }+ defer func() {+ if r := recover(); r != nil {+ err = ec.Recover(ctx, r)+ ec.Error(ctx, err)+ }+ }()+ ctx = graphql.WithFieldContext(ctx, fc)+ if fc.Args, err = ec.field_Query_knowledgeDocuments_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {+ ec.Error(ctx, err)+ return fc, err+ }+ return fc, nil+}++func (ec *executionContext) _Query_knowledgeDocument(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_Query_knowledgeDocument(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return ec.resolvers.Query().KnowledgeDocument(rctx, fc.Args["id"].(string))+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.(*model.KnowledgeDocument)+ fc.Result = res+ return ec.marshalNKnowledgeDocument2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocument(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_Query_knowledgeDocument(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "Query",+ Field: field,+ IsMethod: true,+ IsResolver: true,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ switch field.Name {+ case "id":+ return ec.fieldContext_KnowledgeDocument_id(ctx, field)+ case "docType":+ return ec.fieldContext_KnowledgeDocument_docType(ctx, field)+ case "content":+ return ec.fieldContext_KnowledgeDocument_content(ctx, field)+ case "question":+ return ec.fieldContext_KnowledgeDocument_question(ctx, field)+ case "description":+ return ec.fieldContext_KnowledgeDocument_description(ctx, field)+ case "userId":+ return ec.fieldContext_KnowledgeDocument_userId(ctx, field)+ case "flowId":+ return ec.fieldContext_KnowledgeDocument_flowId(ctx, field)+ case "taskId":+ return ec.fieldContext_KnowledgeDocument_taskId(ctx, field)+ case "subtaskId":+ return ec.fieldContext_KnowledgeDocument_subtaskId(ctx, field)+ case "guideType":+ return ec.fieldContext_KnowledgeDocument_guideType(ctx, field)+ case "answerType":+ return ec.fieldContext_KnowledgeDocument_answerType(ctx, field)+ case "codeLang":+ return ec.fieldContext_KnowledgeDocument_codeLang(ctx, field)+ case "partSize":+ return ec.fieldContext_KnowledgeDocument_partSize(ctx, field)+ case "totalSize":+ return ec.fieldContext_KnowledgeDocument_totalSize(ctx, field)+ case "manual":+ return ec.fieldContext_KnowledgeDocument_manual(ctx, field)+ }+ return nil, fmt.Errorf("no field named %q was found under type KnowledgeDocument", field.Name)+ },+ }+ defer func() {+ if r := recover(); r != nil {+ err = ec.Recover(ctx, r)+ ec.Error(ctx, err)+ }+ }()+ ctx = graphql.WithFieldContext(ctx, fc)+ if fc.Args, err = ec.field_Query_knowledgeDocument_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {+ ec.Error(ctx, err)+ return fc, err+ }+ return fc, nil+}++func (ec *executionContext) _Query_searchKnowledge(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_Query_searchKnowledge(ctx, field)+ if err != nil {+ return graphql.Null+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = graphql.Null+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return ec.resolvers.Query().SearchKnowledge(rctx, fc.Args["query"].(string), fc.Args["filter"].(*model.KnowledgeFilter), fc.Args["limit"].(*int))+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return graphql.Null+ }+ res := resTmp.([]*model.KnowledgeDocumentWithScore)+ fc.Result = res+ return ec.marshalNKnowledgeDocumentWithScore2ᚕᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocumentWithScoreᚄ(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_Query_searchKnowledge(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "Query",+ Field: field,+ IsMethod: true,+ IsResolver: true,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ switch field.Name {+ case "score":+ return ec.fieldContext_KnowledgeDocumentWithScore_score(ctx, field)+ case "document":+ return ec.fieldContext_KnowledgeDocumentWithScore_document(ctx, field)+ }+ return nil, fmt.Errorf("no field named %q was found under type KnowledgeDocumentWithScore", field.Name)+ },+ }+ defer func() {+ if r := recover(); r != nil {+ err = ec.Recover(ctx, r)+ ec.Error(ctx, err)+ }+ }()+ ctx = graphql.WithFieldContext(ctx, fc)+ if fc.Args, err = ec.field_Query_searchKnowledge_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {+ ec.Error(ctx, err)+ return fc, err+ }+ return fc, nil+}+func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {fc, err := ec.fieldContext_Query___type(ctx, field)if err != nil {@@ -25780,8 +27559,152 @@ func (ec *executionContext) fieldContext_Subscription_providerCreated(_ context.return fc, nil}-func (ec *executionContext) _Subscription_providerUpdated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {- fc, err := ec.fieldContext_Subscription_providerUpdated(ctx, field)+func (ec *executionContext) _Subscription_providerUpdated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {+ fc, err := ec.fieldContext_Subscription_providerUpdated(ctx, field)+ if err != nil {+ return nil+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = nil+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return ec.resolvers.Subscription().ProviderUpdated(rctx)+ })+ if err != nil {+ ec.Error(ctx, err)+ return nil+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return nil+ }+ return func(ctx context.Context) graphql.Marshaler {+ select {+ case res, ok := <-resTmp.(<-chan *model.ProviderConfig):+ if !ok {+ return nil+ }+ return graphql.WriterFunc(func(w io.Writer) {+ w.Write([]byte{'{'})+ graphql.MarshalString(field.Alias).MarshalGQL(w)+ w.Write([]byte{':'})+ ec.marshalNProviderConfig2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐProviderConfig(ctx, field.Selections, res).MarshalGQL(w)+ w.Write([]byte{'}'})+ })+ case <-ctx.Done():+ return nil+ }+ }+}++func (ec *executionContext) fieldContext_Subscription_providerUpdated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "Subscription",+ Field: field,+ IsMethod: true,+ IsResolver: true,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ switch field.Name {+ case "id":+ return ec.fieldContext_ProviderConfig_id(ctx, field)+ case "name":+ return ec.fieldContext_ProviderConfig_name(ctx, field)+ case "type":+ return ec.fieldContext_ProviderConfig_type(ctx, field)+ case "agents":+ return ec.fieldContext_ProviderConfig_agents(ctx, field)+ case "createdAt":+ return ec.fieldContext_ProviderConfig_createdAt(ctx, field)+ case "updatedAt":+ return ec.fieldContext_ProviderConfig_updatedAt(ctx, field)+ }+ return nil, fmt.Errorf("no field named %q was found under type ProviderConfig", field.Name)+ },+ }+ return fc, nil+}++func (ec *executionContext) _Subscription_providerDeleted(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {+ fc, err := ec.fieldContext_Subscription_providerDeleted(ctx, field)+ if err != nil {+ return nil+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = nil+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return ec.resolvers.Subscription().ProviderDeleted(rctx)+ })+ if err != nil {+ ec.Error(ctx, err)+ return nil+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return nil+ }+ return func(ctx context.Context) graphql.Marshaler {+ select {+ case res, ok := <-resTmp.(<-chan *model.ProviderConfig):+ if !ok {+ return nil+ }+ return graphql.WriterFunc(func(w io.Writer) {+ w.Write([]byte{'{'})+ graphql.MarshalString(field.Alias).MarshalGQL(w)+ w.Write([]byte{':'})+ ec.marshalNProviderConfig2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐProviderConfig(ctx, field.Selections, res).MarshalGQL(w)+ w.Write([]byte{'}'})+ })+ case <-ctx.Done():+ return nil+ }+ }+}++func (ec *executionContext) fieldContext_Subscription_providerDeleted(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "Subscription",+ Field: field,+ IsMethod: true,+ IsResolver: true,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ switch field.Name {+ case "id":+ return ec.fieldContext_ProviderConfig_id(ctx, field)+ case "name":+ return ec.fieldContext_ProviderConfig_name(ctx, field)+ case "type":+ return ec.fieldContext_ProviderConfig_type(ctx, field)+ case "agents":+ return ec.fieldContext_ProviderConfig_agents(ctx, field)+ case "createdAt":+ return ec.fieldContext_ProviderConfig_createdAt(ctx, field)+ case "updatedAt":+ return ec.fieldContext_ProviderConfig_updatedAt(ctx, field)+ }+ return nil, fmt.Errorf("no field named %q was found under type ProviderConfig", field.Name)+ },+ }+ return fc, nil+}++func (ec *executionContext) _Subscription_apiTokenCreated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {+ fc, err := ec.fieldContext_Subscription_apiTokenCreated(ctx, field)if err != nil {return nil}@@ -25794,7 +27717,7 @@ func (ec *executionContext) _Subscription_providerUpdated(ctx context.Context, f}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return ec.resolvers.Subscription().ProviderUpdated(rctx)+ return ec.resolvers.Subscription().APITokenCreated(rctx)})if err != nil {ec.Error(ctx, err)@@ -25808,7 +27731,7 @@ func (ec *executionContext) _Subscription_providerUpdated(ctx context.Context, f}return func(ctx context.Context) graphql.Marshaler {select {- case res, ok := <-resTmp.(<-chan *model.ProviderConfig):+ case res, ok := <-resTmp.(<-chan *model.APIToken):if !ok {return nil}@@ -25816,7 +27739,7 @@ func (ec *executionContext) _Subscription_providerUpdated(ctx context.Context, fw.Write([]byte{'{'})graphql.MarshalString(field.Alias).MarshalGQL(w)w.Write([]byte{':'})- ec.marshalNProviderConfig2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐProviderConfig(ctx, field.Selections, res).MarshalGQL(w)+ ec.marshalNAPIToken2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐAPIToken(ctx, field.Selections, res).MarshalGQL(w)w.Write([]byte{'}'})})case <-ctx.Done():@@ -25825,7 +27748,7 @@ func (ec *executionContext) _Subscription_providerUpdated(ctx context.Context, f}}-func (ec *executionContext) fieldContext_Subscription_providerUpdated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_Subscription_apiTokenCreated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{Object: "Subscription",Field: field,@@ -25834,26 +27757,32 @@ func (ec *executionContext) fieldContext_Subscription_providerUpdated(_ context.Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {switch field.Name {case "id":- return ec.fieldContext_ProviderConfig_id(ctx, field)+ return ec.fieldContext_APIToken_id(ctx, field)+ case "tokenId":+ return ec.fieldContext_APIToken_tokenId(ctx, field)+ case "userId":+ return ec.fieldContext_APIToken_userId(ctx, field)+ case "roleId":+ return ec.fieldContext_APIToken_roleId(ctx, field)case "name":- return ec.fieldContext_ProviderConfig_name(ctx, field)- case "type":- return ec.fieldContext_ProviderConfig_type(ctx, field)- case "agents":- return ec.fieldContext_ProviderConfig_agents(ctx, field)+ return ec.fieldContext_APIToken_name(ctx, field)+ case "ttl":+ return ec.fieldContext_APIToken_ttl(ctx, field)+ case "status":+ return ec.fieldContext_APIToken_status(ctx, field)case "createdAt":- return ec.fieldContext_ProviderConfig_createdAt(ctx, field)+ return ec.fieldContext_APIToken_createdAt(ctx, field)case "updatedAt":- return ec.fieldContext_ProviderConfig_updatedAt(ctx, field)+ return ec.fieldContext_APIToken_updatedAt(ctx, field)}- return nil, fmt.Errorf("no field named %q was found under type ProviderConfig", field.Name)+ return nil, fmt.Errorf("no field named %q was found under type APIToken", field.Name)},}return fc, nil}-func (ec *executionContext) _Subscription_providerDeleted(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {- fc, err := ec.fieldContext_Subscription_providerDeleted(ctx, field)+func (ec *executionContext) _Subscription_apiTokenUpdated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {+ fc, err := ec.fieldContext_Subscription_apiTokenUpdated(ctx, field)if err != nil {return nil}@@ -25866,7 +27795,7 @@ func (ec *executionContext) _Subscription_providerDeleted(ctx context.Context, f}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return ec.resolvers.Subscription().ProviderDeleted(rctx)+ return ec.resolvers.Subscription().APITokenUpdated(rctx)})if err != nil {ec.Error(ctx, err)@@ -25880,7 +27809,7 @@ func (ec *executionContext) _Subscription_providerDeleted(ctx context.Context, f}return func(ctx context.Context) graphql.Marshaler {select {- case res, ok := <-resTmp.(<-chan *model.ProviderConfig):+ case res, ok := <-resTmp.(<-chan *model.APIToken):if !ok {return nil}@@ -25888,7 +27817,7 @@ func (ec *executionContext) _Subscription_providerDeleted(ctx context.Context, fw.Write([]byte{'{'})graphql.MarshalString(field.Alias).MarshalGQL(w)w.Write([]byte{':'})- ec.marshalNProviderConfig2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐProviderConfig(ctx, field.Selections, res).MarshalGQL(w)+ ec.marshalNAPIToken2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐAPIToken(ctx, field.Selections, res).MarshalGQL(w)w.Write([]byte{'}'})})case <-ctx.Done():@@ -25897,7 +27826,7 @@ func (ec *executionContext) _Subscription_providerDeleted(ctx context.Context, f}}-func (ec *executionContext) fieldContext_Subscription_providerDeleted(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_Subscription_apiTokenUpdated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{Object: "Subscription",Field: field,@@ -25906,26 +27835,32 @@ func (ec *executionContext) fieldContext_Subscription_providerDeleted(_ context.Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {switch field.Name {case "id":- return ec.fieldContext_ProviderConfig_id(ctx, field)+ return ec.fieldContext_APIToken_id(ctx, field)+ case "tokenId":+ return ec.fieldContext_APIToken_tokenId(ctx, field)+ case "userId":+ return ec.fieldContext_APIToken_userId(ctx, field)+ case "roleId":+ return ec.fieldContext_APIToken_roleId(ctx, field)case "name":- return ec.fieldContext_ProviderConfig_name(ctx, field)- case "type":- return ec.fieldContext_ProviderConfig_type(ctx, field)- case "agents":- return ec.fieldContext_ProviderConfig_agents(ctx, field)+ return ec.fieldContext_APIToken_name(ctx, field)+ case "ttl":+ return ec.fieldContext_APIToken_ttl(ctx, field)+ case "status":+ return ec.fieldContext_APIToken_status(ctx, field)case "createdAt":- return ec.fieldContext_ProviderConfig_createdAt(ctx, field)+ return ec.fieldContext_APIToken_createdAt(ctx, field)case "updatedAt":- return ec.fieldContext_ProviderConfig_updatedAt(ctx, field)+ return ec.fieldContext_APIToken_updatedAt(ctx, field)}- return nil, fmt.Errorf("no field named %q was found under type ProviderConfig", field.Name)+ return nil, fmt.Errorf("no field named %q was found under type APIToken", field.Name)},}return fc, nil}-func (ec *executionContext) _Subscription_apiTokenCreated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {- fc, err := ec.fieldContext_Subscription_apiTokenCreated(ctx, field)+func (ec *executionContext) _Subscription_apiTokenDeleted(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {+ fc, err := ec.fieldContext_Subscription_apiTokenDeleted(ctx, field)if err != nil {return nil}@@ -25938,7 +27873,7 @@ func (ec *executionContext) _Subscription_apiTokenCreated(ctx context.Context, f}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return ec.resolvers.Subscription().APITokenCreated(rctx)+ return ec.resolvers.Subscription().APITokenDeleted(rctx)})if err != nil {ec.Error(ctx, err)@@ -25969,7 +27904,7 @@ func (ec *executionContext) _Subscription_apiTokenCreated(ctx context.Context, f}}-func (ec *executionContext) fieldContext_Subscription_apiTokenCreated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_Subscription_apiTokenDeleted(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{Object: "Subscription",Field: field,@@ -26002,8 +27937,8 @@ func (ec *executionContext) fieldContext_Subscription_apiTokenCreated(_ context.return fc, nil}-func (ec *executionContext) _Subscription_apiTokenUpdated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {- fc, err := ec.fieldContext_Subscription_apiTokenUpdated(ctx, field)+func (ec *executionContext) _Subscription_settingsUserUpdated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {+ fc, err := ec.fieldContext_Subscription_settingsUserUpdated(ctx, field)if err != nil {return nil}@@ -26016,7 +27951,7 @@ func (ec *executionContext) _Subscription_apiTokenUpdated(ctx context.Context, f}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return ec.resolvers.Subscription().APITokenUpdated(rctx)+ return ec.resolvers.Subscription().SettingsUserUpdated(rctx)})if err != nil {ec.Error(ctx, err)@@ -26030,7 +27965,7 @@ func (ec *executionContext) _Subscription_apiTokenUpdated(ctx context.Context, f}return func(ctx context.Context) graphql.Marshaler {select {- case res, ok := <-resTmp.(<-chan *model.APIToken):+ case res, ok := <-resTmp.(<-chan *model.UserPreferences):if !ok {return nil}@@ -26038,7 +27973,7 @@ func (ec *executionContext) _Subscription_apiTokenUpdated(ctx context.Context, fw.Write([]byte{'{'})graphql.MarshalString(field.Alias).MarshalGQL(w)w.Write([]byte{':'})- ec.marshalNAPIToken2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐAPIToken(ctx, field.Selections, res).MarshalGQL(w)+ ec.marshalNUserPreferences2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐUserPreferences(ctx, field.Selections, res).MarshalGQL(w)w.Write([]byte{'}'})})case <-ctx.Done():@@ -26047,7 +27982,7 @@ func (ec *executionContext) _Subscription_apiTokenUpdated(ctx context.Context, f}}-func (ec *executionContext) fieldContext_Subscription_apiTokenUpdated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_Subscription_settingsUserUpdated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{Object: "Subscription",Field: field,@@ -26056,32 +27991,18 @@ func (ec *executionContext) fieldContext_Subscription_apiTokenUpdated(_ context.Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {switch field.Name {case "id":- return ec.fieldContext_APIToken_id(ctx, field)- case "tokenId":- return ec.fieldContext_APIToken_tokenId(ctx, field)- case "userId":- return ec.fieldContext_APIToken_userId(ctx, field)- case "roleId":- return ec.fieldContext_APIToken_roleId(ctx, field)- case "name":- return ec.fieldContext_APIToken_name(ctx, field)- case "ttl":- return ec.fieldContext_APIToken_ttl(ctx, field)- case "status":- return ec.fieldContext_APIToken_status(ctx, field)- case "createdAt":- return ec.fieldContext_APIToken_createdAt(ctx, field)- case "updatedAt":- return ec.fieldContext_APIToken_updatedAt(ctx, field)+ return ec.fieldContext_UserPreferences_id(ctx, field)+ case "favoriteFlows":+ return ec.fieldContext_UserPreferences_favoriteFlows(ctx, field)}- return nil, fmt.Errorf("no field named %q was found under type APIToken", field.Name)+ return nil, fmt.Errorf("no field named %q was found under type UserPreferences", field.Name)},}return fc, nil}-func (ec *executionContext) _Subscription_apiTokenDeleted(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {- fc, err := ec.fieldContext_Subscription_apiTokenDeleted(ctx, field)+func (ec *executionContext) _Subscription_flowTemplateCreated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {+ fc, err := ec.fieldContext_Subscription_flowTemplateCreated(ctx, field)if err != nil {return nil}@@ -26094,7 +28015,7 @@ func (ec *executionContext) _Subscription_apiTokenDeleted(ctx context.Context, f}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return ec.resolvers.Subscription().APITokenDeleted(rctx)+ return ec.resolvers.Subscription().FlowTemplateCreated(rctx)})if err != nil {ec.Error(ctx, err)@@ -26108,7 +28029,7 @@ func (ec *executionContext) _Subscription_apiTokenDeleted(ctx context.Context, f}return func(ctx context.Context) graphql.Marshaler {select {- case res, ok := <-resTmp.(<-chan *model.APIToken):+ case res, ok := <-resTmp.(<-chan *model.FlowTemplate):if !ok {return nil}@@ -26116,7 +28037,7 @@ func (ec *executionContext) _Subscription_apiTokenDeleted(ctx context.Context, fw.Write([]byte{'{'})graphql.MarshalString(field.Alias).MarshalGQL(w)w.Write([]byte{':'})- ec.marshalNAPIToken2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐAPIToken(ctx, field.Selections, res).MarshalGQL(w)+ ec.marshalNFlowTemplate2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐFlowTemplate(ctx, field.Selections, res).MarshalGQL(w)w.Write([]byte{'}'})})case <-ctx.Done():@@ -26125,7 +28046,7 @@ func (ec *executionContext) _Subscription_apiTokenDeleted(ctx context.Context, f}}-func (ec *executionContext) fieldContext_Subscription_apiTokenDeleted(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_Subscription_flowTemplateCreated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{Object: "Subscription",Field: field,@@ -26134,32 +28055,26 @@ func (ec *executionContext) fieldContext_Subscription_apiTokenDeleted(_ context.Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {switch field.Name {case "id":- return ec.fieldContext_APIToken_id(ctx, field)- case "tokenId":- return ec.fieldContext_APIToken_tokenId(ctx, field)+ return ec.fieldContext_FlowTemplate_id(ctx, field)case "userId":- return ec.fieldContext_APIToken_userId(ctx, field)- case "roleId":- return ec.fieldContext_APIToken_roleId(ctx, field)- case "name":- return ec.fieldContext_APIToken_name(ctx, field)- case "ttl":- return ec.fieldContext_APIToken_ttl(ctx, field)- case "status":- return ec.fieldContext_APIToken_status(ctx, field)+ return ec.fieldContext_FlowTemplate_userId(ctx, field)+ case "title":+ return ec.fieldContext_FlowTemplate_title(ctx, field)+ case "text":+ return ec.fieldContext_FlowTemplate_text(ctx, field)case "createdAt":- return ec.fieldContext_APIToken_createdAt(ctx, field)+ return ec.fieldContext_FlowTemplate_createdAt(ctx, field)case "updatedAt":- return ec.fieldContext_APIToken_updatedAt(ctx, field)+ return ec.fieldContext_FlowTemplate_updatedAt(ctx, field)}- return nil, fmt.Errorf("no field named %q was found under type APIToken", field.Name)+ return nil, fmt.Errorf("no field named %q was found under type FlowTemplate", field.Name)},}return fc, nil}-func (ec *executionContext) _Subscription_settingsUserUpdated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {- fc, err := ec.fieldContext_Subscription_settingsUserUpdated(ctx, field)+func (ec *executionContext) _Subscription_flowTemplateUpdated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {+ fc, err := ec.fieldContext_Subscription_flowTemplateUpdated(ctx, field)if err != nil {return nil}@@ -26172,7 +28087,7 @@ func (ec *executionContext) _Subscription_settingsUserUpdated(ctx context.Contex}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return ec.resolvers.Subscription().SettingsUserUpdated(rctx)+ return ec.resolvers.Subscription().FlowTemplateUpdated(rctx)})if err != nil {ec.Error(ctx, err)@@ -26186,7 +28101,7 @@ func (ec *executionContext) _Subscription_settingsUserUpdated(ctx context.Contex}return func(ctx context.Context) graphql.Marshaler {select {- case res, ok := <-resTmp.(<-chan *model.UserPreferences):+ case res, ok := <-resTmp.(<-chan *model.FlowTemplate):if !ok {return nil}@@ -26194,7 +28109,7 @@ func (ec *executionContext) _Subscription_settingsUserUpdated(ctx context.Contexw.Write([]byte{'{'})graphql.MarshalString(field.Alias).MarshalGQL(w)w.Write([]byte{':'})- ec.marshalNUserPreferences2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐUserPreferences(ctx, field.Selections, res).MarshalGQL(w)+ ec.marshalNFlowTemplate2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐFlowTemplate(ctx, field.Selections, res).MarshalGQL(w)w.Write([]byte{'}'})})case <-ctx.Done():@@ -26203,7 +28118,7 @@ func (ec *executionContext) _Subscription_settingsUserUpdated(ctx context.Contex}}-func (ec *executionContext) fieldContext_Subscription_settingsUserUpdated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_Subscription_flowTemplateUpdated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{Object: "Subscription",Field: field,@@ -26212,18 +28127,26 @@ func (ec *executionContext) fieldContext_Subscription_settingsUserUpdated(_ contChild: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {switch field.Name {case "id":- return ec.fieldContext_UserPreferences_id(ctx, field)- case "favoriteFlows":- return ec.fieldContext_UserPreferences_favoriteFlows(ctx, field)+ return ec.fieldContext_FlowTemplate_id(ctx, field)+ case "userId":+ return ec.fieldContext_FlowTemplate_userId(ctx, field)+ case "title":+ return ec.fieldContext_FlowTemplate_title(ctx, field)+ case "text":+ return ec.fieldContext_FlowTemplate_text(ctx, field)+ case "createdAt":+ return ec.fieldContext_FlowTemplate_createdAt(ctx, field)+ case "updatedAt":+ return ec.fieldContext_FlowTemplate_updatedAt(ctx, field)}- return nil, fmt.Errorf("no field named %q was found under type UserPreferences", field.Name)+ return nil, fmt.Errorf("no field named %q was found under type FlowTemplate", field.Name)},}return fc, nil}-func (ec *executionContext) _Subscription_flowTemplateCreated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {- fc, err := ec.fieldContext_Subscription_flowTemplateCreated(ctx, field)+func (ec *executionContext) _Subscription_flowTemplateDeleted(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {+ fc, err := ec.fieldContext_Subscription_flowTemplateDeleted(ctx, field)if err != nil {return nil}@@ -26236,7 +28159,7 @@ func (ec *executionContext) _Subscription_flowTemplateCreated(ctx context.Contex}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return ec.resolvers.Subscription().FlowTemplateCreated(rctx)+ return ec.resolvers.Subscription().FlowTemplateDeleted(rctx)})if err != nil {ec.Error(ctx, err)@@ -26267,7 +28190,7 @@ func (ec *executionContext) _Subscription_flowTemplateCreated(ctx context.Contex}}-func (ec *executionContext) fieldContext_Subscription_flowTemplateCreated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_Subscription_flowTemplateDeleted(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{Object: "Subscription",Field: field,@@ -26294,8 +28217,8 @@ func (ec *executionContext) fieldContext_Subscription_flowTemplateCreated(_ contreturn fc, nil}-func (ec *executionContext) _Subscription_flowTemplateUpdated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {- fc, err := ec.fieldContext_Subscription_flowTemplateUpdated(ctx, field)+func (ec *executionContext) _Subscription_resourceAdded(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {+ fc, err := ec.fieldContext_Subscription_resourceAdded(ctx, field)if err != nil {return nil}@@ -26308,7 +28231,7 @@ func (ec *executionContext) _Subscription_flowTemplateUpdated(ctx context.Contex}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return ec.resolvers.Subscription().FlowTemplateUpdated(rctx)+ return ec.resolvers.Subscription().ResourceAdded(rctx)})if err != nil {ec.Error(ctx, err)@@ -26322,7 +28245,7 @@ func (ec *executionContext) _Subscription_flowTemplateUpdated(ctx context.Contex}return func(ctx context.Context) graphql.Marshaler {select {- case res, ok := <-resTmp.(<-chan *model.FlowTemplate):+ case res, ok := <-resTmp.(<-chan *model.UserResource):if !ok {return nil}@@ -26330,7 +28253,7 @@ func (ec *executionContext) _Subscription_flowTemplateUpdated(ctx context.Contexw.Write([]byte{'{'})graphql.MarshalString(field.Alias).MarshalGQL(w)w.Write([]byte{':'})- ec.marshalNFlowTemplate2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐFlowTemplate(ctx, field.Selections, res).MarshalGQL(w)+ ec.marshalNUserResource2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐUserResource(ctx, field.Selections, res).MarshalGQL(w)w.Write([]byte{'}'})})case <-ctx.Done():@@ -26339,7 +28262,7 @@ func (ec *executionContext) _Subscription_flowTemplateUpdated(ctx context.Contex}}-func (ec *executionContext) fieldContext_Subscription_flowTemplateUpdated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_Subscription_resourceAdded(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{Object: "Subscription",Field: field,@@ -26348,26 +28271,30 @@ func (ec *executionContext) fieldContext_Subscription_flowTemplateUpdated(_ contChild: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {switch field.Name {case "id":- return ec.fieldContext_FlowTemplate_id(ctx, field)+ return ec.fieldContext_UserResource_id(ctx, field)case "userId":- return ec.fieldContext_FlowTemplate_userId(ctx, field)- case "title":- return ec.fieldContext_FlowTemplate_title(ctx, field)- case "text":- return ec.fieldContext_FlowTemplate_text(ctx, field)+ return ec.fieldContext_UserResource_userId(ctx, field)+ case "name":+ return ec.fieldContext_UserResource_name(ctx, field)+ case "path":+ return ec.fieldContext_UserResource_path(ctx, field)+ case "size":+ return ec.fieldContext_UserResource_size(ctx, field)+ case "isDir":+ return ec.fieldContext_UserResource_isDir(ctx, field)case "createdAt":- return ec.fieldContext_FlowTemplate_createdAt(ctx, field)+ return ec.fieldContext_UserResource_createdAt(ctx, field)case "updatedAt":- return ec.fieldContext_FlowTemplate_updatedAt(ctx, field)+ return ec.fieldContext_UserResource_updatedAt(ctx, field)}- return nil, fmt.Errorf("no field named %q was found under type FlowTemplate", field.Name)+ return nil, fmt.Errorf("no field named %q was found under type UserResource", field.Name)},}return fc, nil}-func (ec *executionContext) _Subscription_flowTemplateDeleted(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {- fc, err := ec.fieldContext_Subscription_flowTemplateDeleted(ctx, field)+func (ec *executionContext) _Subscription_resourceUpdated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {+ fc, err := ec.fieldContext_Subscription_resourceUpdated(ctx, field)if err != nil {return nil}@@ -26380,7 +28307,7 @@ func (ec *executionContext) _Subscription_flowTemplateDeleted(ctx context.Contex}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return ec.resolvers.Subscription().FlowTemplateDeleted(rctx)+ return ec.resolvers.Subscription().ResourceUpdated(rctx)})if err != nil {ec.Error(ctx, err)@@ -26394,7 +28321,7 @@ func (ec *executionContext) _Subscription_flowTemplateDeleted(ctx context.Contex}return func(ctx context.Context) graphql.Marshaler {select {- case res, ok := <-resTmp.(<-chan *model.FlowTemplate):+ case res, ok := <-resTmp.(<-chan *model.UserResource):if !ok {return nil}@@ -26402,7 +28329,7 @@ func (ec *executionContext) _Subscription_flowTemplateDeleted(ctx context.Contexw.Write([]byte{'{'})graphql.MarshalString(field.Alias).MarshalGQL(w)w.Write([]byte{':'})- ec.marshalNFlowTemplate2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐFlowTemplate(ctx, field.Selections, res).MarshalGQL(w)+ ec.marshalNUserResource2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐUserResource(ctx, field.Selections, res).MarshalGQL(w)w.Write([]byte{'}'})})case <-ctx.Done():@@ -26411,7 +28338,7 @@ func (ec *executionContext) _Subscription_flowTemplateDeleted(ctx context.Contex}}-func (ec *executionContext) fieldContext_Subscription_flowTemplateDeleted(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_Subscription_resourceUpdated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{Object: "Subscription",Field: field,@@ -26420,26 +28347,30 @@ func (ec *executionContext) fieldContext_Subscription_flowTemplateDeleted(_ contChild: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {switch field.Name {case "id":- return ec.fieldContext_FlowTemplate_id(ctx, field)+ return ec.fieldContext_UserResource_id(ctx, field)case "userId":- return ec.fieldContext_FlowTemplate_userId(ctx, field)- case "title":- return ec.fieldContext_FlowTemplate_title(ctx, field)- case "text":- return ec.fieldContext_FlowTemplate_text(ctx, field)+ return ec.fieldContext_UserResource_userId(ctx, field)+ case "name":+ return ec.fieldContext_UserResource_name(ctx, field)+ case "path":+ return ec.fieldContext_UserResource_path(ctx, field)+ case "size":+ return ec.fieldContext_UserResource_size(ctx, field)+ case "isDir":+ return ec.fieldContext_UserResource_isDir(ctx, field)case "createdAt":- return ec.fieldContext_FlowTemplate_createdAt(ctx, field)+ return ec.fieldContext_UserResource_createdAt(ctx, field)case "updatedAt":- return ec.fieldContext_FlowTemplate_updatedAt(ctx, field)+ return ec.fieldContext_UserResource_updatedAt(ctx, field)}- return nil, fmt.Errorf("no field named %q was found under type FlowTemplate", field.Name)+ return nil, fmt.Errorf("no field named %q was found under type UserResource", field.Name)},}return fc, nil}-func (ec *executionContext) _Subscription_resourceAdded(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {- fc, err := ec.fieldContext_Subscription_resourceAdded(ctx, field)+func (ec *executionContext) _Subscription_resourceDeleted(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {+ fc, err := ec.fieldContext_Subscription_resourceDeleted(ctx, field)if err != nil {return nil}@@ -26452,7 +28383,7 @@ func (ec *executionContext) _Subscription_resourceAdded(ctx context.Context, fie}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return ec.resolvers.Subscription().ResourceAdded(rctx)+ return ec.resolvers.Subscription().ResourceDeleted(rctx)})if err != nil {ec.Error(ctx, err)@@ -26483,7 +28414,7 @@ func (ec *executionContext) _Subscription_resourceAdded(ctx context.Context, fie}}-func (ec *executionContext) fieldContext_Subscription_resourceAdded(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_Subscription_resourceDeleted(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{Object: "Subscription",Field: field,@@ -26514,8 +28445,8 @@ func (ec *executionContext) fieldContext_Subscription_resourceAdded(_ context.Coreturn fc, nil}-func (ec *executionContext) _Subscription_resourceUpdated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {- fc, err := ec.fieldContext_Subscription_resourceUpdated(ctx, field)+func (ec *executionContext) _Subscription_knowledgeDocumentCreated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {+ fc, err := ec.fieldContext_Subscription_knowledgeDocumentCreated(ctx, field)if err != nil {return nil}@@ -26528,7 +28459,7 @@ func (ec *executionContext) _Subscription_resourceUpdated(ctx context.Context, f}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return ec.resolvers.Subscription().ResourceUpdated(rctx)+ return ec.resolvers.Subscription().KnowledgeDocumentCreated(rctx)})if err != nil {ec.Error(ctx, err)@@ -26542,7 +28473,7 @@ func (ec *executionContext) _Subscription_resourceUpdated(ctx context.Context, f}return func(ctx context.Context) graphql.Marshaler {select {- case res, ok := <-resTmp.(<-chan *model.UserResource):+ case res, ok := <-resTmp.(<-chan *model.KnowledgeDocument):if !ok {return nil}@@ -26550,7 +28481,7 @@ func (ec *executionContext) _Subscription_resourceUpdated(ctx context.Context, fw.Write([]byte{'{'})graphql.MarshalString(field.Alias).MarshalGQL(w)w.Write([]byte{':'})- ec.marshalNUserResource2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐUserResource(ctx, field.Selections, res).MarshalGQL(w)+ ec.marshalNKnowledgeDocument2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocument(ctx, field.Selections, res).MarshalGQL(w)w.Write([]byte{'}'})})case <-ctx.Done():@@ -26559,7 +28490,7 @@ func (ec *executionContext) _Subscription_resourceUpdated(ctx context.Context, f}}-func (ec *executionContext) fieldContext_Subscription_resourceUpdated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_Subscription_knowledgeDocumentCreated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{Object: "Subscription",Field: field,@@ -26568,30 +28499,44 @@ func (ec *executionContext) fieldContext_Subscription_resourceUpdated(_ context.Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {switch field.Name {case "id":- return ec.fieldContext_UserResource_id(ctx, field)+ return ec.fieldContext_KnowledgeDocument_id(ctx, field)+ case "docType":+ return ec.fieldContext_KnowledgeDocument_docType(ctx, field)+ case "content":+ return ec.fieldContext_KnowledgeDocument_content(ctx, field)+ case "question":+ return ec.fieldContext_KnowledgeDocument_question(ctx, field)+ case "description":+ return ec.fieldContext_KnowledgeDocument_description(ctx, field)case "userId":- return ec.fieldContext_UserResource_userId(ctx, field)- case "name":- return ec.fieldContext_UserResource_name(ctx, field)- case "path":- return ec.fieldContext_UserResource_path(ctx, field)- case "size":- return ec.fieldContext_UserResource_size(ctx, field)- case "isDir":- return ec.fieldContext_UserResource_isDir(ctx, field)- case "createdAt":- return ec.fieldContext_UserResource_createdAt(ctx, field)- case "updatedAt":- return ec.fieldContext_UserResource_updatedAt(ctx, field)+ return ec.fieldContext_KnowledgeDocument_userId(ctx, field)+ case "flowId":+ return ec.fieldContext_KnowledgeDocument_flowId(ctx, field)+ case "taskId":+ return ec.fieldContext_KnowledgeDocument_taskId(ctx, field)+ case "subtaskId":+ return ec.fieldContext_KnowledgeDocument_subtaskId(ctx, field)+ case "guideType":+ return ec.fieldContext_KnowledgeDocument_guideType(ctx, field)+ case "answerType":+ return ec.fieldContext_KnowledgeDocument_answerType(ctx, field)+ case "codeLang":+ return ec.fieldContext_KnowledgeDocument_codeLang(ctx, field)+ case "partSize":+ return ec.fieldContext_KnowledgeDocument_partSize(ctx, field)+ case "totalSize":+ return ec.fieldContext_KnowledgeDocument_totalSize(ctx, field)+ case "manual":+ return ec.fieldContext_KnowledgeDocument_manual(ctx, field)}- return nil, fmt.Errorf("no field named %q was found under type UserResource", field.Name)+ return nil, fmt.Errorf("no field named %q was found under type KnowledgeDocument", field.Name)},}return fc, nil}-func (ec *executionContext) _Subscription_resourceDeleted(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {- fc, err := ec.fieldContext_Subscription_resourceDeleted(ctx, field)+func (ec *executionContext) _Subscription_knowledgeDocumentUpdated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {+ fc, err := ec.fieldContext_Subscription_knowledgeDocumentUpdated(ctx, field)if err != nil {return nil}@@ -26604,7 +28549,7 @@ func (ec *executionContext) _Subscription_resourceDeleted(ctx context.Context, f}()resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {ctx = rctx // use context from middleware stack in children- return ec.resolvers.Subscription().ResourceDeleted(rctx)+ return ec.resolvers.Subscription().KnowledgeDocumentUpdated(rctx)})if err != nil {ec.Error(ctx, err)@@ -26618,7 +28563,7 @@ func (ec *executionContext) _Subscription_resourceDeleted(ctx context.Context, f}return func(ctx context.Context) graphql.Marshaler {select {- case res, ok := <-resTmp.(<-chan *model.UserResource):+ case res, ok := <-resTmp.(<-chan *model.KnowledgeDocument):if !ok {return nil}@@ -26626,7 +28571,7 @@ func (ec *executionContext) _Subscription_resourceDeleted(ctx context.Context, fw.Write([]byte{'{'})graphql.MarshalString(field.Alias).MarshalGQL(w)w.Write([]byte{':'})- ec.marshalNUserResource2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐUserResource(ctx, field.Selections, res).MarshalGQL(w)+ ec.marshalNKnowledgeDocument2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocument(ctx, field.Selections, res).MarshalGQL(w)w.Write([]byte{'}'})})case <-ctx.Done():@@ -26635,7 +28580,7 @@ func (ec *executionContext) _Subscription_resourceDeleted(ctx context.Context, f}}-func (ec *executionContext) fieldContext_Subscription_resourceDeleted(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+func (ec *executionContext) fieldContext_Subscription_knowledgeDocumentUpdated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {fc = &graphql.FieldContext{Object: "Subscription",Field: field,@@ -26644,23 +28589,127 @@ func (ec *executionContext) fieldContext_Subscription_resourceDeleted(_ context.Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {switch field.Name {case "id":- return ec.fieldContext_UserResource_id(ctx, field)+ return ec.fieldContext_KnowledgeDocument_id(ctx, field)+ case "docType":+ return ec.fieldContext_KnowledgeDocument_docType(ctx, field)+ case "content":+ return ec.fieldContext_KnowledgeDocument_content(ctx, field)+ case "question":+ return ec.fieldContext_KnowledgeDocument_question(ctx, field)+ case "description":+ return ec.fieldContext_KnowledgeDocument_description(ctx, field)case "userId":- return ec.fieldContext_UserResource_userId(ctx, field)- case "name":- return ec.fieldContext_UserResource_name(ctx, field)- case "path":- return ec.fieldContext_UserResource_path(ctx, field)- case "size":- return ec.fieldContext_UserResource_size(ctx, field)- case "isDir":- return ec.fieldContext_UserResource_isDir(ctx, field)- case "createdAt":- return ec.fieldContext_UserResource_createdAt(ctx, field)- case "updatedAt":- return ec.fieldContext_UserResource_updatedAt(ctx, field)+ return ec.fieldContext_KnowledgeDocument_userId(ctx, field)+ case "flowId":+ return ec.fieldContext_KnowledgeDocument_flowId(ctx, field)+ case "taskId":+ return ec.fieldContext_KnowledgeDocument_taskId(ctx, field)+ case "subtaskId":+ return ec.fieldContext_KnowledgeDocument_subtaskId(ctx, field)+ case "guideType":+ return ec.fieldContext_KnowledgeDocument_guideType(ctx, field)+ case "answerType":+ return ec.fieldContext_KnowledgeDocument_answerType(ctx, field)+ case "codeLang":+ return ec.fieldContext_KnowledgeDocument_codeLang(ctx, field)+ case "partSize":+ return ec.fieldContext_KnowledgeDocument_partSize(ctx, field)+ case "totalSize":+ return ec.fieldContext_KnowledgeDocument_totalSize(ctx, field)+ case "manual":+ return ec.fieldContext_KnowledgeDocument_manual(ctx, field)}- return nil, fmt.Errorf("no field named %q was found under type UserResource", field.Name)+ return nil, fmt.Errorf("no field named %q was found under type KnowledgeDocument", field.Name)+ },+ }+ return fc, nil+}++func (ec *executionContext) _Subscription_knowledgeDocumentDeleted(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {+ fc, err := ec.fieldContext_Subscription_knowledgeDocumentDeleted(ctx, field)+ if err != nil {+ return nil+ }+ ctx = graphql.WithFieldContext(ctx, fc)+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = nil+ }+ }()+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {+ ctx = rctx // use context from middleware stack in children+ return ec.resolvers.Subscription().KnowledgeDocumentDeleted(rctx)+ })+ if err != nil {+ ec.Error(ctx, err)+ return nil+ }+ if resTmp == nil {+ if !graphql.HasFieldError(ctx, fc) {+ ec.Errorf(ctx, "must not be null")+ }+ return nil+ }+ return func(ctx context.Context) graphql.Marshaler {+ select {+ case res, ok := <-resTmp.(<-chan *model.KnowledgeDocument):+ if !ok {+ return nil+ }+ return graphql.WriterFunc(func(w io.Writer) {+ w.Write([]byte{'{'})+ graphql.MarshalString(field.Alias).MarshalGQL(w)+ w.Write([]byte{':'})+ ec.marshalNKnowledgeDocument2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocument(ctx, field.Selections, res).MarshalGQL(w)+ w.Write([]byte{'}'})+ })+ case <-ctx.Done():+ return nil+ }+ }+}++func (ec *executionContext) fieldContext_Subscription_knowledgeDocumentDeleted(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "Subscription",+ Field: field,+ IsMethod: true,+ IsResolver: true,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ switch field.Name {+ case "id":+ return ec.fieldContext_KnowledgeDocument_id(ctx, field)+ case "docType":+ return ec.fieldContext_KnowledgeDocument_docType(ctx, field)+ case "content":+ return ec.fieldContext_KnowledgeDocument_content(ctx, field)+ case "question":+ return ec.fieldContext_KnowledgeDocument_question(ctx, field)+ case "description":+ return ec.fieldContext_KnowledgeDocument_description(ctx, field)+ case "userId":+ return ec.fieldContext_KnowledgeDocument_userId(ctx, field)+ case "flowId":+ return ec.fieldContext_KnowledgeDocument_flowId(ctx, field)+ case "taskId":+ return ec.fieldContext_KnowledgeDocument_taskId(ctx, field)+ case "subtaskId":+ return ec.fieldContext_KnowledgeDocument_subtaskId(ctx, field)+ case "guideType":+ return ec.fieldContext_KnowledgeDocument_guideType(ctx, field)+ case "answerType":+ return ec.fieldContext_KnowledgeDocument_answerType(ctx, field)+ case "codeLang":+ return ec.fieldContext_KnowledgeDocument_codeLang(ctx, field)+ case "partSize":+ return ec.fieldContext_KnowledgeDocument_partSize(ctx, field)+ case "totalSize":+ return ec.fieldContext_KnowledgeDocument_totalSize(ctx, field)+ case "manual":+ return ec.fieldContext_KnowledgeDocument_manual(ctx, field)+ }+ return nil, fmt.Errorf("no field named %q was found under type KnowledgeDocument", field.Name)},}return fc, nil@@ -32917,6 +34966,137 @@ func (ec *executionContext) unmarshalInputCreateFlowTemplateInput(ctx context.Coreturn it, nil}+func (ec *executionContext) unmarshalInputCreateKnowledgeDocumentInput(ctx context.Context, obj interface{}) (model.CreateKnowledgeDocumentInput, error) {+ var it model.CreateKnowledgeDocumentInput+ asMap := map[string]interface{}{}+ for k, v := range obj.(map[string]interface{}) {+ asMap[k] = v+ }++ fieldsInOrder := [...]string{"docType", "content", "question", "description", "guideType", "answerType", "codeLang"}+ for _, k := range fieldsInOrder {+ v, ok := asMap[k]+ if !ok {+ continue+ }+ switch k {+ case "docType":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("docType"))+ data, err := ec.unmarshalNKnowledgeDocType2pentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocType(ctx, v)+ if err != nil {+ return it, err+ }+ it.DocType = data+ case "content":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("content"))+ data, err := ec.unmarshalNString2string(ctx, v)+ if err != nil {+ return it, err+ }+ it.Content = data+ case "question":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("question"))+ data, err := ec.unmarshalNString2string(ctx, v)+ if err != nil {+ return it, err+ }+ it.Question = data+ case "description":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("description"))+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)+ if err != nil {+ return it, err+ }+ it.Description = data+ case "guideType":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("guideType"))+ data, err := ec.unmarshalOKnowledgeGuideType2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeGuideType(ctx, v)+ if err != nil {+ return it, err+ }+ it.GuideType = data+ case "answerType":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("answerType"))+ data, err := ec.unmarshalOKnowledgeAnswerType2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeAnswerType(ctx, v)+ if err != nil {+ return it, err+ }+ it.AnswerType = data+ case "codeLang":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeLang"))+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)+ if err != nil {+ return it, err+ }+ it.CodeLang = data+ }+ }++ return it, nil+}++func (ec *executionContext) unmarshalInputKnowledgeFilter(ctx context.Context, obj interface{}) (model.KnowledgeFilter, error) {+ var it model.KnowledgeFilter+ asMap := map[string]interface{}{}+ for k, v := range obj.(map[string]interface{}) {+ asMap[k] = v+ }++ fieldsInOrder := [...]string{"docTypes", "guideTypes", "answerTypes", "codeLangs", "flowId", "manual"}+ for _, k := range fieldsInOrder {+ v, ok := asMap[k]+ if !ok {+ continue+ }+ switch k {+ case "docTypes":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("docTypes"))+ data, err := ec.unmarshalOKnowledgeDocType2ᚕpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocTypeᚄ(ctx, v)+ if err != nil {+ return it, err+ }+ it.DocTypes = data+ case "guideTypes":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("guideTypes"))+ data, err := ec.unmarshalOKnowledgeGuideType2ᚕpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeGuideTypeᚄ(ctx, v)+ if err != nil {+ return it, err+ }+ it.GuideTypes = data+ case "answerTypes":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("answerTypes"))+ data, err := ec.unmarshalOKnowledgeAnswerType2ᚕpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeAnswerTypeᚄ(ctx, v)+ if err != nil {+ return it, err+ }+ it.AnswerTypes = data+ case "codeLangs":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeLangs"))+ data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v)+ if err != nil {+ return it, err+ }+ it.CodeLangs = data+ case "flowId":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId"))+ data, err := ec.unmarshalOID2ᚖint64(ctx, v)+ if err != nil {+ return it, err+ }+ it.FlowID = data+ case "manual":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("manual"))+ data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v)+ if err != nil {+ return it, err+ }+ it.Manual = data+ }+ }++ return it, nil+}+func (ec *executionContext) unmarshalInputModelPriceInput(ctx context.Context, obj interface{}) (model.ModelPrice, error) {var it model.ModelPriceasMap := map[string]interface{}{}@@ -33067,6 +35247,68 @@ func (ec *executionContext) unmarshalInputUpdateFlowTemplateInput(ctx context.Coreturn it, nil}+func (ec *executionContext) unmarshalInputUpdateKnowledgeDocumentInput(ctx context.Context, obj interface{}) (model.UpdateKnowledgeDocumentInput, error) {+ var it model.UpdateKnowledgeDocumentInput+ asMap := map[string]interface{}{}+ for k, v := range obj.(map[string]interface{}) {+ asMap[k] = v+ }++ fieldsInOrder := [...]string{"content", "question", "description", "guideType", "answerType", "codeLang"}+ for _, k := range fieldsInOrder {+ v, ok := asMap[k]+ if !ok {+ continue+ }+ switch k {+ case "content":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("content"))+ data, err := ec.unmarshalNString2string(ctx, v)+ if err != nil {+ return it, err+ }+ it.Content = data+ case "question":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("question"))+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)+ if err != nil {+ return it, err+ }+ it.Question = data+ case "description":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("description"))+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)+ if err != nil {+ return it, err+ }+ it.Description = data+ case "guideType":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("guideType"))+ data, err := ec.unmarshalOKnowledgeGuideType2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeGuideType(ctx, v)+ if err != nil {+ return it, err+ }+ it.GuideType = data+ case "answerType":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("answerType"))+ data, err := ec.unmarshalOKnowledgeAnswerType2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeAnswerType(ctx, v)+ if err != nil {+ return it, err+ }+ it.AnswerType = data+ case "codeLang":+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeLang"))+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)+ if err != nil {+ return it, err+ }+ it.CodeLang = data+ }+ }++ return it, nil+}+// endregion **************************** input.gotpl *****************************// region ************************** interface.gotpl ***************************@@ -34585,39 +36827,171 @@ func (ec *executionContext) _FlowsStats(ctx context.Context, sel ast.SelectionSereturn out}-var functionToolcallsStatsImplementors = []string{"FunctionToolcallsStats"}+var functionToolcallsStatsImplementors = []string{"FunctionToolcallsStats"}++func (ec *executionContext) _FunctionToolcallsStats(ctx context.Context, sel ast.SelectionSet, obj *model.FunctionToolcallsStats) graphql.Marshaler {+ fields := graphql.CollectFields(ec.OperationContext, sel, functionToolcallsStatsImplementors)++ out := graphql.NewFieldSet(fields)+ deferred := make(map[string]*graphql.FieldSet)+ for i, field := range fields {+ switch field.Name {+ case "__typename":+ out.Values[i] = graphql.MarshalString("FunctionToolcallsStats")+ case "functionName":+ out.Values[i] = ec._FunctionToolcallsStats_functionName(ctx, field, obj)+ if out.Values[i] == graphql.Null {+ out.Invalids+++ }+ case "isAgent":+ out.Values[i] = ec._FunctionToolcallsStats_isAgent(ctx, field, obj)+ if out.Values[i] == graphql.Null {+ out.Invalids+++ }+ case "totalCount":+ out.Values[i] = ec._FunctionToolcallsStats_totalCount(ctx, field, obj)+ if out.Values[i] == graphql.Null {+ out.Invalids+++ }+ case "totalDurationSeconds":+ out.Values[i] = ec._FunctionToolcallsStats_totalDurationSeconds(ctx, field, obj)+ if out.Values[i] == graphql.Null {+ out.Invalids+++ }+ case "avgDurationSeconds":+ out.Values[i] = ec._FunctionToolcallsStats_avgDurationSeconds(ctx, field, obj)+ if out.Values[i] == graphql.Null {+ out.Invalids+++ }+ default:+ panic("unknown field " + strconv.Quote(field.Name))+ }+ }+ out.Dispatch(ctx)+ if out.Invalids > 0 {+ return graphql.Null+ }++ atomic.AddInt32(&ec.deferred, int32(len(deferred)))++ for label, dfs := range deferred {+ ec.processDeferredGroup(graphql.DeferredGroup{+ Label: label,+ Path: graphql.GetPath(ctx),+ FieldSet: dfs,+ Context: ctx,+ })+ }++ return out+}++var knowledgeDocumentImplementors = []string{"KnowledgeDocument"}-func (ec *executionContext) _FunctionToolcallsStats(ctx context.Context, sel ast.SelectionSet, obj *model.FunctionToolcallsStats) graphql.Marshaler {- fields := graphql.CollectFields(ec.OperationContext, sel, functionToolcallsStatsImplementors)+func (ec *executionContext) _KnowledgeDocument(ctx context.Context, sel ast.SelectionSet, obj *model.KnowledgeDocument) graphql.Marshaler {+ fields := graphql.CollectFields(ec.OperationContext, sel, knowledgeDocumentImplementors)out := graphql.NewFieldSet(fields)deferred := make(map[string]*graphql.FieldSet)for i, field := range fields {switch field.Name {case "__typename":- out.Values[i] = graphql.MarshalString("FunctionToolcallsStats")- case "functionName":- out.Values[i] = ec._FunctionToolcallsStats_functionName(ctx, field, obj)+ out.Values[i] = graphql.MarshalString("KnowledgeDocument")+ case "id":+ out.Values[i] = ec._KnowledgeDocument_id(ctx, field, obj)if out.Values[i] == graphql.Null {out.Invalids++}- case "isAgent":- out.Values[i] = ec._FunctionToolcallsStats_isAgent(ctx, field, obj)+ case "docType":+ out.Values[i] = ec._KnowledgeDocument_docType(ctx, field, obj)if out.Values[i] == graphql.Null {out.Invalids++}- case "totalCount":- out.Values[i] = ec._FunctionToolcallsStats_totalCount(ctx, field, obj)+ case "content":+ out.Values[i] = ec._KnowledgeDocument_content(ctx, field, obj)if out.Values[i] == graphql.Null {out.Invalids++}- case "totalDurationSeconds":- out.Values[i] = ec._FunctionToolcallsStats_totalDurationSeconds(ctx, field, obj)+ case "question":+ out.Values[i] = ec._KnowledgeDocument_question(ctx, field, obj)if out.Values[i] == graphql.Null {out.Invalids++}- case "avgDurationSeconds":- out.Values[i] = ec._FunctionToolcallsStats_avgDurationSeconds(ctx, field, obj)+ case "description":+ out.Values[i] = ec._KnowledgeDocument_description(ctx, field, obj)+ case "userId":+ out.Values[i] = ec._KnowledgeDocument_userId(ctx, field, obj)+ if out.Values[i] == graphql.Null {+ out.Invalids+++ }+ case "flowId":+ out.Values[i] = ec._KnowledgeDocument_flowId(ctx, field, obj)+ case "taskId":+ out.Values[i] = ec._KnowledgeDocument_taskId(ctx, field, obj)+ case "subtaskId":+ out.Values[i] = ec._KnowledgeDocument_subtaskId(ctx, field, obj)+ case "guideType":+ out.Values[i] = ec._KnowledgeDocument_guideType(ctx, field, obj)+ case "answerType":+ out.Values[i] = ec._KnowledgeDocument_answerType(ctx, field, obj)+ case "codeLang":+ out.Values[i] = ec._KnowledgeDocument_codeLang(ctx, field, obj)+ case "partSize":+ out.Values[i] = ec._KnowledgeDocument_partSize(ctx, field, obj)+ if out.Values[i] == graphql.Null {+ out.Invalids+++ }+ case "totalSize":+ out.Values[i] = ec._KnowledgeDocument_totalSize(ctx, field, obj)+ if out.Values[i] == graphql.Null {+ out.Invalids+++ }+ case "manual":+ out.Values[i] = ec._KnowledgeDocument_manual(ctx, field, obj)+ if out.Values[i] == graphql.Null {+ out.Invalids+++ }+ default:+ panic("unknown field " + strconv.Quote(field.Name))+ }+ }+ out.Dispatch(ctx)+ if out.Invalids > 0 {+ return graphql.Null+ }++ atomic.AddInt32(&ec.deferred, int32(len(deferred)))++ for label, dfs := range deferred {+ ec.processDeferredGroup(graphql.DeferredGroup{+ Label: label,+ Path: graphql.GetPath(ctx),+ FieldSet: dfs,+ Context: ctx,+ })+ }++ return out+}++var knowledgeDocumentWithScoreImplementors = []string{"KnowledgeDocumentWithScore"}++func (ec *executionContext) _KnowledgeDocumentWithScore(ctx context.Context, sel ast.SelectionSet, obj *model.KnowledgeDocumentWithScore) graphql.Marshaler {+ fields := graphql.CollectFields(ec.OperationContext, sel, knowledgeDocumentWithScoreImplementors)++ out := graphql.NewFieldSet(fields)+ deferred := make(map[string]*graphql.FieldSet)+ for i, field := range fields {+ switch field.Name {+ case "__typename":+ out.Values[i] = graphql.MarshalString("KnowledgeDocumentWithScore")+ case "score":+ out.Values[i] = ec._KnowledgeDocumentWithScore_score(ctx, field, obj)+ if out.Values[i] == graphql.Null {+ out.Invalids+++ }+ case "document":+ out.Values[i] = ec._KnowledgeDocumentWithScore_document(ctx, field, obj)if out.Values[i] == graphql.Null {out.Invalids++}@@ -35131,6 +37505,27 @@ func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet)if out.Values[i] == graphql.Null {out.Invalids++}+ case "createKnowledgeDocument":+ out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {+ return ec._Mutation_createKnowledgeDocument(ctx, field)+ })+ if out.Values[i] == graphql.Null {+ out.Invalids+++ }+ case "updateKnowledgeDocument":+ out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {+ return ec._Mutation_updateKnowledgeDocument(ctx, field)+ })+ if out.Values[i] == graphql.Null {+ out.Invalids+++ }+ case "deleteKnowledgeDocument":+ out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {+ return ec._Mutation_deleteKnowledgeDocument(ctx, field)+ })+ if out.Values[i] == graphql.Null {+ out.Invalids+++ }default:panic("unknown field " + strconv.Quote(field.Name))}@@ -36531,6 +38926,72 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) grfunc(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })}+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })+ case "knowledgeDocuments":+ field := field++ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ }+ }()+ res = ec._Query_knowledgeDocuments(ctx, field)+ if res == graphql.Null {+ atomic.AddUint32(&fs.Invalids, 1)+ }+ return res+ }++ rrm := func(ctx context.Context) graphql.Marshaler {+ return ec.OperationContext.RootResolverMiddleware(ctx,+ func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })+ }++ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })+ case "knowledgeDocument":+ field := field++ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ }+ }()+ res = ec._Query_knowledgeDocument(ctx, field)+ if res == graphql.Null {+ atomic.AddUint32(&fs.Invalids, 1)+ }+ return res+ }++ rrm := func(ctx context.Context) graphql.Marshaler {+ return ec.OperationContext.RootResolverMiddleware(ctx,+ func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })+ }++ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })+ case "searchKnowledge":+ field := field++ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ }+ }()+ res = ec._Query_searchKnowledge(ctx, field)+ if res == graphql.Null {+ atomic.AddUint32(&fs.Invalids, 1)+ }+ return res+ }++ rrm := func(ctx context.Context) graphql.Marshaler {+ return ec.OperationContext.RootResolverMiddleware(ctx,+ func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })+ }+out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })case "__type":out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {@@ -36875,6 +39336,12 @@ func (ec *executionContext) _Subscription(ctx context.Context, sel ast.Selectionreturn ec._Subscription_resourceUpdated(ctx, fields[0])case "resourceDeleted":return ec._Subscription_resourceDeleted(ctx, fields[0])+ case "knowledgeDocumentCreated":+ return ec._Subscription_knowledgeDocumentCreated(ctx, fields[0])+ case "knowledgeDocumentUpdated":+ return ec._Subscription_knowledgeDocumentUpdated(ctx, fields[0])+ case "knowledgeDocumentDeleted":+ return ec._Subscription_knowledgeDocumentDeleted(ctx, fields[0])default:panic("unknown field " + strconv.Quote(fields[0].Name))}@@ -38479,6 +40946,11 @@ func (ec *executionContext) unmarshalNCreateFlowTemplateInput2pentagiᚋpkgᚋgrreturn res, graphql.ErrorOnPath(ctx, err)}+func (ec *executionContext) unmarshalNCreateKnowledgeDocumentInput2pentagiᚋpkgᚋgraphᚋmodelᚐCreateKnowledgeDocumentInput(ctx context.Context, v interface{}) (model.CreateKnowledgeDocumentInput, error) {+ res, err := ec.unmarshalInputCreateKnowledgeDocumentInput(ctx, v)+ return res, graphql.ErrorOnPath(ctx, err)+}+func (ec *executionContext) marshalNDailyFlowsStats2ᚕᚖpentagiᚋpkgᚋgraphᚋmodelᚐDailyFlowsStatsᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.DailyFlowsStats) graphql.Marshaler {ret := make(graphql.Array, len(v))var wg sync.WaitGroup@@ -39028,6 +41500,148 @@ func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.Selectireturn res}+func (ec *executionContext) unmarshalNKnowledgeAnswerType2pentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeAnswerType(ctx context.Context, v interface{}) (model.KnowledgeAnswerType, error) {+ var res model.KnowledgeAnswerType+ err := res.UnmarshalGQL(v)+ return res, graphql.ErrorOnPath(ctx, err)+}++func (ec *executionContext) marshalNKnowledgeAnswerType2pentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeAnswerType(ctx context.Context, sel ast.SelectionSet, v model.KnowledgeAnswerType) graphql.Marshaler {+ return v+}++func (ec *executionContext) unmarshalNKnowledgeDocType2pentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocType(ctx context.Context, v interface{}) (model.KnowledgeDocType, error) {+ var res model.KnowledgeDocType+ err := res.UnmarshalGQL(v)+ return res, graphql.ErrorOnPath(ctx, err)+}++func (ec *executionContext) marshalNKnowledgeDocType2pentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocType(ctx context.Context, sel ast.SelectionSet, v model.KnowledgeDocType) graphql.Marshaler {+ return v+}++func (ec *executionContext) marshalNKnowledgeDocument2pentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocument(ctx context.Context, sel ast.SelectionSet, v model.KnowledgeDocument) graphql.Marshaler {+ return ec._KnowledgeDocument(ctx, sel, &v)+}++func (ec *executionContext) marshalNKnowledgeDocument2ᚕᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocumentᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.KnowledgeDocument) graphql.Marshaler {+ ret := make(graphql.Array, len(v))+ var wg sync.WaitGroup+ isLen1 := len(v) == 1+ if !isLen1 {+ wg.Add(len(v))+ }+ for i := range v {+ i := i+ fc := &graphql.FieldContext{+ Index: &i,+ Result: &v[i],+ }+ ctx := graphql.WithFieldContext(ctx, fc)+ f := func(i int) {+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = nil+ }+ }()+ if !isLen1 {+ defer wg.Done()+ }+ ret[i] = ec.marshalNKnowledgeDocument2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocument(ctx, sel, v[i])+ }+ if isLen1 {+ f(i)+ } else {+ go f(i)+ }++ }+ wg.Wait()++ for _, e := range ret {+ if e == graphql.Null {+ return graphql.Null+ }+ }++ return ret+}++func (ec *executionContext) marshalNKnowledgeDocument2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocument(ctx context.Context, sel ast.SelectionSet, v *model.KnowledgeDocument) graphql.Marshaler {+ if v == nil {+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {+ ec.Errorf(ctx, "the requested element is null which the schema does not allow")+ }+ return graphql.Null+ }+ return ec._KnowledgeDocument(ctx, sel, v)+}++func (ec *executionContext) marshalNKnowledgeDocumentWithScore2ᚕᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocumentWithScoreᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.KnowledgeDocumentWithScore) graphql.Marshaler {+ ret := make(graphql.Array, len(v))+ var wg sync.WaitGroup+ isLen1 := len(v) == 1+ if !isLen1 {+ wg.Add(len(v))+ }+ for i := range v {+ i := i+ fc := &graphql.FieldContext{+ Index: &i,+ Result: &v[i],+ }+ ctx := graphql.WithFieldContext(ctx, fc)+ f := func(i int) {+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = nil+ }+ }()+ if !isLen1 {+ defer wg.Done()+ }+ ret[i] = ec.marshalNKnowledgeDocumentWithScore2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocumentWithScore(ctx, sel, v[i])+ }+ if isLen1 {+ f(i)+ } else {+ go f(i)+ }++ }+ wg.Wait()++ for _, e := range ret {+ if e == graphql.Null {+ return graphql.Null+ }+ }++ return ret+}++func (ec *executionContext) marshalNKnowledgeDocumentWithScore2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocumentWithScore(ctx context.Context, sel ast.SelectionSet, v *model.KnowledgeDocumentWithScore) graphql.Marshaler {+ if v == nil {+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {+ ec.Errorf(ctx, "the requested element is null which the schema does not allow")+ }+ return graphql.Null+ }+ return ec._KnowledgeDocumentWithScore(ctx, sel, v)+}++func (ec *executionContext) unmarshalNKnowledgeGuideType2pentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeGuideType(ctx context.Context, v interface{}) (model.KnowledgeGuideType, error) {+ var res model.KnowledgeGuideType+ err := res.UnmarshalGQL(v)+ return res, graphql.ErrorOnPath(ctx, err)+}++func (ec *executionContext) marshalNKnowledgeGuideType2pentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeGuideType(ctx context.Context, sel ast.SelectionSet, v model.KnowledgeGuideType) graphql.Marshaler {+ return v+}+func (ec *executionContext) marshalNMessageLog2pentagiᚋpkgᚋgraphᚋmodelᚐMessageLog(ctx context.Context, sel ast.SelectionSet, v model.MessageLog) graphql.Marshaler {return ec._MessageLog(ctx, sel, &v)}@@ -39840,6 +42454,11 @@ func (ec *executionContext) unmarshalNUpdateFlowTemplateInput2pentagiᚋpkgᚋgrreturn res, graphql.ErrorOnPath(ctx, err)}+func (ec *executionContext) unmarshalNUpdateKnowledgeDocumentInput2pentagiᚋpkgᚋgraphᚋmodelᚐUpdateKnowledgeDocumentInput(ctx context.Context, v interface{}) (model.UpdateKnowledgeDocumentInput, error) {+ res, err := ec.unmarshalInputUpdateKnowledgeDocumentInput(ctx, v)+ return res, graphql.ErrorOnPath(ctx, err)+}+func (ec *executionContext) marshalNUsageStats2pentagiᚋpkgᚋgraphᚋmodelᚐUsageStats(ctx context.Context, sel ast.SelectionSet, v model.UsageStats) graphql.Marshaler {return ec._UsageStats(ctx, sel, &v)}@@ -40541,6 +43160,247 @@ func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.Selereturn res}+func (ec *executionContext) unmarshalOKnowledgeAnswerType2ᚕpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeAnswerTypeᚄ(ctx context.Context, v interface{}) ([]model.KnowledgeAnswerType, error) {+ if v == nil {+ return nil, nil+ }+ var vSlice []interface{}+ if v != nil {+ vSlice = graphql.CoerceList(v)+ }+ var err error+ res := make([]model.KnowledgeAnswerType, len(vSlice))+ for i := range vSlice {+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))+ res[i], err = ec.unmarshalNKnowledgeAnswerType2pentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeAnswerType(ctx, vSlice[i])+ if err != nil {+ return nil, err+ }+ }+ return res, nil+}++func (ec *executionContext) marshalOKnowledgeAnswerType2ᚕpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeAnswerTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []model.KnowledgeAnswerType) graphql.Marshaler {+ if v == nil {+ return graphql.Null+ }+ ret := make(graphql.Array, len(v))+ var wg sync.WaitGroup+ isLen1 := len(v) == 1+ if !isLen1 {+ wg.Add(len(v))+ }+ for i := range v {+ i := i+ fc := &graphql.FieldContext{+ Index: &i,+ Result: &v[i],+ }+ ctx := graphql.WithFieldContext(ctx, fc)+ f := func(i int) {+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = nil+ }+ }()+ if !isLen1 {+ defer wg.Done()+ }+ ret[i] = ec.marshalNKnowledgeAnswerType2pentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeAnswerType(ctx, sel, v[i])+ }+ if isLen1 {+ f(i)+ } else {+ go f(i)+ }++ }+ wg.Wait()++ for _, e := range ret {+ if e == graphql.Null {+ return graphql.Null+ }+ }++ return ret+}++func (ec *executionContext) unmarshalOKnowledgeAnswerType2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeAnswerType(ctx context.Context, v interface{}) (*model.KnowledgeAnswerType, error) {+ if v == nil {+ return nil, nil+ }+ var res = new(model.KnowledgeAnswerType)+ err := res.UnmarshalGQL(v)+ return res, graphql.ErrorOnPath(ctx, err)+}++func (ec *executionContext) marshalOKnowledgeAnswerType2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeAnswerType(ctx context.Context, sel ast.SelectionSet, v *model.KnowledgeAnswerType) graphql.Marshaler {+ if v == nil {+ return graphql.Null+ }+ return v+}++func (ec *executionContext) unmarshalOKnowledgeDocType2ᚕpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocTypeᚄ(ctx context.Context, v interface{}) ([]model.KnowledgeDocType, error) {+ if v == nil {+ return nil, nil+ }+ var vSlice []interface{}+ if v != nil {+ vSlice = graphql.CoerceList(v)+ }+ var err error+ res := make([]model.KnowledgeDocType, len(vSlice))+ for i := range vSlice {+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))+ res[i], err = ec.unmarshalNKnowledgeDocType2pentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocType(ctx, vSlice[i])+ if err != nil {+ return nil, err+ }+ }+ return res, nil+}++func (ec *executionContext) marshalOKnowledgeDocType2ᚕpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []model.KnowledgeDocType) graphql.Marshaler {+ if v == nil {+ return graphql.Null+ }+ ret := make(graphql.Array, len(v))+ var wg sync.WaitGroup+ isLen1 := len(v) == 1+ if !isLen1 {+ wg.Add(len(v))+ }+ for i := range v {+ i := i+ fc := &graphql.FieldContext{+ Index: &i,+ Result: &v[i],+ }+ ctx := graphql.WithFieldContext(ctx, fc)+ f := func(i int) {+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = nil+ }+ }()+ if !isLen1 {+ defer wg.Done()+ }+ ret[i] = ec.marshalNKnowledgeDocType2pentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeDocType(ctx, sel, v[i])+ }+ if isLen1 {+ f(i)+ } else {+ go f(i)+ }++ }+ wg.Wait()++ for _, e := range ret {+ if e == graphql.Null {+ return graphql.Null+ }+ }++ return ret+}++func (ec *executionContext) unmarshalOKnowledgeFilter2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeFilter(ctx context.Context, v interface{}) (*model.KnowledgeFilter, error) {+ if v == nil {+ return nil, nil+ }+ res, err := ec.unmarshalInputKnowledgeFilter(ctx, v)+ return &res, graphql.ErrorOnPath(ctx, err)+}++func (ec *executionContext) unmarshalOKnowledgeGuideType2ᚕpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeGuideTypeᚄ(ctx context.Context, v interface{}) ([]model.KnowledgeGuideType, error) {+ if v == nil {+ return nil, nil+ }+ var vSlice []interface{}+ if v != nil {+ vSlice = graphql.CoerceList(v)+ }+ var err error+ res := make([]model.KnowledgeGuideType, len(vSlice))+ for i := range vSlice {+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))+ res[i], err = ec.unmarshalNKnowledgeGuideType2pentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeGuideType(ctx, vSlice[i])+ if err != nil {+ return nil, err+ }+ }+ return res, nil+}++func (ec *executionContext) marshalOKnowledgeGuideType2ᚕpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeGuideTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []model.KnowledgeGuideType) graphql.Marshaler {+ if v == nil {+ return graphql.Null+ }+ ret := make(graphql.Array, len(v))+ var wg sync.WaitGroup+ isLen1 := len(v) == 1+ if !isLen1 {+ wg.Add(len(v))+ }+ for i := range v {+ i := i+ fc := &graphql.FieldContext{+ Index: &i,+ Result: &v[i],+ }+ ctx := graphql.WithFieldContext(ctx, fc)+ f := func(i int) {+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = nil+ }+ }()+ if !isLen1 {+ defer wg.Done()+ }+ ret[i] = ec.marshalNKnowledgeGuideType2pentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeGuideType(ctx, sel, v[i])+ }+ if isLen1 {+ f(i)+ } else {+ go f(i)+ }++ }+ wg.Wait()++ for _, e := range ret {+ if e == graphql.Null {+ return graphql.Null+ }+ }++ return ret+}++func (ec *executionContext) unmarshalOKnowledgeGuideType2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeGuideType(ctx context.Context, v interface{}) (*model.KnowledgeGuideType, error) {+ if v == nil {+ return nil, nil+ }+ var res = new(model.KnowledgeGuideType)+ err := res.UnmarshalGQL(v)+ return res, graphql.ErrorOnPath(ctx, err)+}++func (ec *executionContext) marshalOKnowledgeGuideType2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐKnowledgeGuideType(ctx context.Context, sel ast.SelectionSet, v *model.KnowledgeGuideType) graphql.Marshaler {+ if v == nil {+ return graphql.Null+ }+ return v+}+func (ec *executionContext) marshalOMessageLog2ᚕᚖpentagiᚋpkgᚋgraphᚋmodelᚐMessageLogᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.MessageLog) graphql.Marshaler {if v == nil {return graphql.Null@@ -40845,6 +43705,44 @@ func (ec *executionContext) marshalOSearchLog2ᚕᚖpentagiᚋpkgᚋgraphᚋmodereturn ret}+func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {+ if v == nil {+ return nil, nil+ }+ var vSlice []interface{}+ if v != nil {+ vSlice = graphql.CoerceList(v)+ }+ var err error+ res := make([]string, len(vSlice))+ for i := range vSlice {+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))+ res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])+ if err != nil {+ return nil, err+ }+ }+ return res, nil+}++func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {+ if v == nil {+ return graphql.Null+ }+ ret := make(graphql.Array, len(v))+ for i := range v {+ ret[i] = ec.marshalNString2string(ctx, sel, v[i])+ }++ for _, e := range ret {+ if e == graphql.Null {+ return graphql.Null+ }+ }++ return ret+}+func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {if v == nil {return nil, nildiff --git a/backend/pkg/graph/model/models_gen.go b/backend/pkg/graph/model/models_gen.goindex 05025de4..c7314c1d 100644--- a/backend/pkg/graph/model/models_gen.go+++ b/backend/pkg/graph/model/models_gen.go@@ -147,6 +147,16 @@ type CreateFlowTemplateInput struct {Text string `json:"text"`}+type CreateKnowledgeDocumentInput struct {+ DocType KnowledgeDocType `json:"docType"`+ Content string `json:"content"`+ Question string `json:"question"`+ Description *string `json:"description,omitempty"`+ GuideType *KnowledgeGuideType `json:"guideType,omitempty"`+ AnswerType *KnowledgeAnswerType `json:"answerType,omitempty"`+ CodeLang *string `json:"codeLang,omitempty"`+}+type DailyFlowsStats struct {Date time.Time `json:"date"`Stats *FlowsStats `json:"stats"`@@ -249,6 +259,38 @@ type FunctionToolcallsStats struct {AvgDurationSeconds float64 `json:"avgDurationSeconds"`}+type KnowledgeDocument struct {+ ID string `json:"id"`+ DocType KnowledgeDocType `json:"docType"`+ Content string `json:"content"`+ Question string `json:"question"`+ Description *string `json:"description,omitempty"`+ UserID int64 `json:"userId"`+ FlowID *int64 `json:"flowId,omitempty"`+ TaskID *int64 `json:"taskId,omitempty"`+ SubtaskID *int64 `json:"subtaskId,omitempty"`+ GuideType *KnowledgeGuideType `json:"guideType,omitempty"`+ AnswerType *KnowledgeAnswerType `json:"answerType,omitempty"`+ CodeLang *string `json:"codeLang,omitempty"`+ PartSize int `json:"partSize"`+ TotalSize int `json:"totalSize"`+ Manual bool `json:"manual"`+}++type KnowledgeDocumentWithScore struct {+ Score float64 `json:"score"`+ Document *KnowledgeDocument `json:"document"`+}++type KnowledgeFilter struct {+ DocTypes []KnowledgeDocType `json:"docTypes,omitempty"`+ GuideTypes []KnowledgeGuideType `json:"guideTypes,omitempty"`+ AnswerTypes []KnowledgeAnswerType `json:"answerTypes,omitempty"`+ CodeLangs []string `json:"codeLangs,omitempty"`+ FlowID *int64 `json:"flowId,omitempty"`+ Manual *bool `json:"manual,omitempty"`+}+type MessageLog struct {ID int64 `json:"id"`Type MessageLogType `json:"type"`@@ -513,6 +555,15 @@ type UpdateFlowTemplateInput struct {Text string `json:"text"`}+type UpdateKnowledgeDocumentInput struct {+ Content string `json:"content"`+ Question *string `json:"question,omitempty"`+ Description *string `json:"description,omitempty"`+ GuideType *KnowledgeGuideType `json:"guideType,omitempty"`+ AnswerType *KnowledgeAnswerType `json:"answerType,omitempty"`+ CodeLang *string `json:"codeLang,omitempty"`+}+type UsageStats struct {TotalUsageIn int `json:"totalUsageIn"`TotalUsageOut int `json:"totalUsageOut"`@@ -690,6 +741,145 @@ func (e AgentType) MarshalGQL(w io.Writer) {fmt.Fprint(w, strconv.Quote(e.String()))}+type KnowledgeAnswerType string++const (+ KnowledgeAnswerTypeGuide KnowledgeAnswerType = "guide"+ KnowledgeAnswerTypeVulnerability KnowledgeAnswerType = "vulnerability"+ KnowledgeAnswerTypeCode KnowledgeAnswerType = "code"+ KnowledgeAnswerTypeTool KnowledgeAnswerType = "tool"+ KnowledgeAnswerTypeOther KnowledgeAnswerType = "other"+)++var AllKnowledgeAnswerType = []KnowledgeAnswerType{+ KnowledgeAnswerTypeGuide,+ KnowledgeAnswerTypeVulnerability,+ KnowledgeAnswerTypeCode,+ KnowledgeAnswerTypeTool,+ KnowledgeAnswerTypeOther,+}++func (e KnowledgeAnswerType) IsValid() bool {+ switch e {+ case KnowledgeAnswerTypeGuide, KnowledgeAnswerTypeVulnerability, KnowledgeAnswerTypeCode, KnowledgeAnswerTypeTool, KnowledgeAnswerTypeOther:+ return true+ }+ return false+}++func (e KnowledgeAnswerType) String() string {+ return string(e)+}++func (e *KnowledgeAnswerType) UnmarshalGQL(v interface{}) error {+ str, ok := v.(string)+ if !ok {+ return fmt.Errorf("enums must be strings")+ }++ *e = KnowledgeAnswerType(str)+ if !e.IsValid() {+ return fmt.Errorf("%s is not a valid KnowledgeAnswerType", str)+ }+ return nil+}++func (e KnowledgeAnswerType) MarshalGQL(w io.Writer) {+ fmt.Fprint(w, strconv.Quote(e.String()))+}++type KnowledgeDocType string++const (+ KnowledgeDocTypeAnswer KnowledgeDocType = "answer"+ KnowledgeDocTypeGuide KnowledgeDocType = "guide"+ KnowledgeDocTypeCode KnowledgeDocType = "code"+)++var AllKnowledgeDocType = []KnowledgeDocType{+ KnowledgeDocTypeAnswer,+ KnowledgeDocTypeGuide,+ KnowledgeDocTypeCode,+}++func (e KnowledgeDocType) IsValid() bool {+ switch e {+ case KnowledgeDocTypeAnswer, KnowledgeDocTypeGuide, KnowledgeDocTypeCode:+ return true+ }+ return false+}++func (e KnowledgeDocType) String() string {+ return string(e)+}++func (e *KnowledgeDocType) UnmarshalGQL(v interface{}) error {+ str, ok := v.(string)+ if !ok {+ return fmt.Errorf("enums must be strings")+ }++ *e = KnowledgeDocType(str)+ if !e.IsValid() {+ return fmt.Errorf("%s is not a valid KnowledgeDocType", str)+ }+ return nil+}++func (e KnowledgeDocType) MarshalGQL(w io.Writer) {+ fmt.Fprint(w, strconv.Quote(e.String()))+}++type KnowledgeGuideType string++const (+ KnowledgeGuideTypeInstall KnowledgeGuideType = "install"+ KnowledgeGuideTypeConfigure KnowledgeGuideType = "configure"+ KnowledgeGuideTypeUse KnowledgeGuideType = "use"+ KnowledgeGuideTypePentest KnowledgeGuideType = "pentest"+ KnowledgeGuideTypeDevelopment KnowledgeGuideType = "development"+ KnowledgeGuideTypeOther KnowledgeGuideType = "other"+)++var AllKnowledgeGuideType = []KnowledgeGuideType{+ KnowledgeGuideTypeInstall,+ KnowledgeGuideTypeConfigure,+ KnowledgeGuideTypeUse,+ KnowledgeGuideTypePentest,+ KnowledgeGuideTypeDevelopment,+ KnowledgeGuideTypeOther,+}++func (e KnowledgeGuideType) IsValid() bool {+ switch e {+ case KnowledgeGuideTypeInstall, KnowledgeGuideTypeConfigure, KnowledgeGuideTypeUse, KnowledgeGuideTypePentest, KnowledgeGuideTypeDevelopment, KnowledgeGuideTypeOther:+ return true+ }+ return false+}++func (e KnowledgeGuideType) String() string {+ return string(e)+}++func (e *KnowledgeGuideType) UnmarshalGQL(v interface{}) error {+ str, ok := v.(string)+ if !ok {+ return fmt.Errorf("enums must be strings")+ }++ *e = KnowledgeGuideType(str)+ if !e.IsValid() {+ return fmt.Errorf("%s is not a valid KnowledgeGuideType", str)+ }+ return nil+}++func (e KnowledgeGuideType) MarshalGQL(w io.Writer) {+ fmt.Fprint(w, strconv.Quote(e.String()))+}+type MessageLogType stringconst (diff --git a/backend/pkg/graph/resolver.go b/backend/pkg/graph/resolver.goindex f3f7bf34..e7fa6719 100644--- a/backend/pkg/graph/resolver.go+++ b/backend/pkg/graph/resolver.go@@ -4,6 +4,7 @@ import ("pentagi/pkg/config""pentagi/pkg/controller""pentagi/pkg/database"+ "pentagi/pkg/database/knowledge""pentagi/pkg/graph/subscriptions""pentagi/pkg/providers""pentagi/pkg/server/auth"@@ -25,4 +26,5 @@ type Resolver struct {ProvidersCtrl providers.ProviderControllerController controller.FlowControllerSubscriptions subscriptions.SubscriptionsController+ Knowledge knowledge.KnowledgeStore}diff --git a/backend/pkg/graph/schema.graphqls b/backend/pkg/graph/schema.graphqlsindex 803c77f1..70d7e691 100644--- a/backend/pkg/graph/schema.graphqls+++ b/backend/pkg/graph/schema.graphqls@@ -821,6 +821,93 @@ input AgentsConfigInput {pentester: AgentConfigInput!}+# ==================== Knowledge (Vector Store) Types ====================++# Document type discriminator stored in cmetadata doc_type field+enum KnowledgeDocType {+ answer+ guide+ code+}++# Guide sub-type stored in cmetadata guide_type field+enum KnowledgeGuideType {+ install+ configure+ use+ pentest+ development+ other+}++# Answer sub-type stored in cmetadata answer_type field+enum KnowledgeAnswerType {+ guide+ vulnerability+ code+ tool+ other+}++# A single document stored in the pgvector knowledge base+type KnowledgeDocument {+ # UUID primary key of the embedding row+ id: String!+ docType: KnowledgeDocType!+ # Chunk text; empty string when withContent=false was requested (to save bandwidth)+ content: String!+ question: String!+ description: String+ userId: ID!+ flowId: ID+ taskId: ID+ subtaskId: ID+ guideType: KnowledgeGuideType+ answerType: KnowledgeAnswerType+ codeLang: String+ partSize: Int!+ totalSize: Int!+ # True when document was created manually via API rather than by an agent+ manual: Boolean!+}++# Knowledge document enriched with semantic similarity score from vector search+type KnowledgeDocumentWithScore {+ score: Float!+ document: KnowledgeDocument!+}++# Optional filter for listing or searching knowledge documents+input KnowledgeFilter {+ docTypes: [KnowledgeDocType!]+ guideTypes: [KnowledgeGuideType!]+ answerTypes: [KnowledgeAnswerType!]+ codeLangs: [String!]+ flowId: ID+ manual: Boolean+}++# Input for creating a new knowledge document manually+input CreateKnowledgeDocumentInput {+ docType: KnowledgeDocType!+ content: String!+ question: String!+ description: String+ guideType: KnowledgeGuideType+ answerType: KnowledgeAnswerType+ codeLang: String+}++# Input for updating an existing knowledge document; non-null fields trigger re-embedding+input UpdateKnowledgeDocumentInput {+ content: String!+ question: String+ description: String+ guideType: KnowledgeGuideType+ answerType: KnowledgeAnswerType+ codeLang: String+}+# ==================== GraphQL Operations ====================type Query {@@ -884,6 +971,11 @@ type Query {# User Resources managementresources(path: String, recursive: Boolean): [UserResource!]!++ # Knowledge (vector store) management+ knowledgeDocuments(filter: KnowledgeFilter, withContent: Boolean!): [KnowledgeDocument!]!+ knowledgeDocument(id: String!): KnowledgeDocument!+ searchKnowledge(query: String!, filter: KnowledgeFilter, limit: Int): [KnowledgeDocumentWithScore!]!}type Mutation {@@ -927,6 +1019,11 @@ type Mutation {createFlowTemplate(input: CreateFlowTemplateInput!): FlowTemplate!updateFlowTemplate(templateId: ID!, input: UpdateFlowTemplateInput!): FlowTemplate!deleteFlowTemplate(templateId: ID!): ResultType!++ # Knowledge (vector store) management+ createKnowledgeDocument(input: CreateKnowledgeDocumentInput!): KnowledgeDocument!+ updateKnowledgeDocument(id: String!, input: UpdateKnowledgeDocumentInput!): KnowledgeDocument!+ deleteKnowledgeDocument(id: String!): ResultType!}type Subscription {@@ -980,4 +1077,9 @@ type Subscription {resourceAdded: UserResource!resourceUpdated: UserResource!resourceDeleted: UserResource!++ # Knowledge (vector store) events+ knowledgeDocumentCreated: KnowledgeDocument!+ knowledgeDocumentUpdated: KnowledgeDocument!+ knowledgeDocumentDeleted: KnowledgeDocument!}diff --git a/backend/pkg/graph/schema.resolvers.go b/backend/pkg/graph/schema.resolvers.goindex 2d766d08..334c2f58 100644--- a/backend/pkg/graph/schema.resolvers.go+++ b/backend/pkg/graph/schema.resolvers.go@@ -217,6 +217,14 @@ func (r *mutationResolver) DeleteFlow(ctx context.Context, flowID int64) (model.return model.ResultTypeError, err}+ // Best-effort cleanup: remove accumulated long-term memory documents for this+ // flow from the vector store. They will never be re-used after the flow is gone.+ if err := r.DB.DeleteFlowMemoryDocuments(ctx,+ database.StringToNullString(fmt.Sprintf("%d", flow.ID)),+ ); err != nil {+ r.Logger.WithError(err).Warnf("failed to clean up memory documents for deleted flow %d", flow.ID)+ }+publisher := r.Subscriptions.NewFlowPublisher(flow.UserID, flow.ID)publisher.FlowUpdated(ctx, flow, containers)publisher.FlowDeleted(ctx, flow, containers)@@ -1113,6 +1121,65 @@ func (r *mutationResolver) DeleteFlowTemplate(ctx context.Context, templateID inreturn model.ResultTypeSuccess, nil}+// CreateKnowledgeDocument is the resolver for the createKnowledgeDocument field.+func (r *mutationResolver) CreateKnowledgeDocument(ctx context.Context, input model.CreateKnowledgeDocumentInput) (*model.KnowledgeDocument, error) {+ uid, _, err := validatePermission(ctx, "knowledge.create")+ if err != nil {+ return nil, err+ }++ r.Logger.WithFields(logrus.Fields{+ "uid": uid,+ "doc_type": input.DocType,+ }).Debug("create knowledge document")++ return r.Knowledge.CreateDocument(ctx, uid, input)+}++// UpdateKnowledgeDocument is the resolver for the updateKnowledgeDocument field.+func (r *mutationResolver) UpdateKnowledgeDocument(ctx context.Context, id string, input model.UpdateKnowledgeDocumentInput) (*model.KnowledgeDocument, error) {+ uid, admin, err := validatePermission(ctx, "knowledge.edit")+ if err != nil {+ return nil, err+ }++ r.Logger.WithFields(logrus.Fields{+ "uid": uid,+ "admin": admin,+ "id": id,+ }).Debug("update knowledge document")++ if admin {+ return r.Knowledge.UpdateDocument(ctx, uid, id, input)+ }+ return r.Knowledge.UpdateUserDocument(ctx, uid, id, input)+}++// DeleteKnowledgeDocument is the resolver for the deleteKnowledgeDocument field.+func (r *mutationResolver) DeleteKnowledgeDocument(ctx context.Context, id string) (model.ResultType, error) {+ uid, admin, err := validatePermission(ctx, "knowledge.delete")+ if err != nil {+ return model.ResultTypeError, err+ }++ r.Logger.WithFields(logrus.Fields{+ "uid": uid,+ "admin": admin,+ "id": id,+ }).Debug("delete knowledge document")++ var deleteErr error+ if admin {+ deleteErr = r.Knowledge.DeleteDocument(ctx, uid, id)+ } else {+ deleteErr = r.Knowledge.DeleteUserDocument(ctx, uid, id)+ }+ if deleteErr != nil {+ return model.ResultTypeError, deleteErr+ }+ return model.ResultTypeSuccess, nil+}+// Providers is the resolver for the providers field.func (r *queryResolver) Providers(ctx context.Context) ([]*model.Provider, error) {uid, _, err := validatePermission(ctx, "providers.view")@@ -2310,6 +2377,68 @@ func (r *queryResolver) Resources(ctx context.Context, path *string, recursive *return converter.ConvertUserResources(recs), nil}+// KnowledgeDocuments is the resolver for the knowledgeDocuments field.+func (r *queryResolver) KnowledgeDocuments(ctx context.Context, filter *model.KnowledgeFilter, withContent bool) ([]*model.KnowledgeDocument, error) {+ uid, admin, err := validatePermission(ctx, "knowledge.view")+ if err != nil {+ return nil, err+ }++ r.Logger.WithFields(logrus.Fields{+ "uid": uid,+ "admin": admin,+ "with_content": withContent,+ }).Debug("list knowledge documents")++ if admin {+ return r.Knowledge.ListDocuments(ctx, filter, withContent)+ }+ return r.Knowledge.ListUserDocuments(ctx, uid, filter, withContent)+}++// KnowledgeDocument is the resolver for the knowledgeDocument field.+func (r *queryResolver) KnowledgeDocument(ctx context.Context, id string) (*model.KnowledgeDocument, error) {+ uid, admin, err := validatePermission(ctx, "knowledge.view")+ if err != nil {+ return nil, err+ }++ r.Logger.WithFields(logrus.Fields{+ "uid": uid,+ "admin": admin,+ "id": id,+ }).Debug("get knowledge document")++ if admin {+ return r.Knowledge.GetDocument(ctx, id)+ }+ return r.Knowledge.GetUserDocument(ctx, uid, id)+}++// SearchKnowledge is the resolver for the searchKnowledge field.+func (r *queryResolver) SearchKnowledge(ctx context.Context, query string, filter *model.KnowledgeFilter, limit *int) ([]*model.KnowledgeDocumentWithScore, error) {+ uid, admin, err := validatePermission(ctx, "knowledge.search")+ if err != nil {+ return nil, err+ }++ r.Logger.WithFields(logrus.Fields{+ "uid": uid,+ "admin": admin,+ "query": query[:min(len(query), 200)],+ }).Debug("search knowledge documents")++ lim := 0+ if limit != nil {+ lim = *limit+ }++ if admin {+ return r.Knowledge.SearchDocuments(ctx, query, filter, lim)+ }+ return r.Knowledge.SearchUserDocuments(ctx, uid, query, filter, lim)+}+// FlowCreated is the resolver for the flowCreated field.func (r *subscriptionResolver) FlowCreated(ctx context.Context) (<-chan *model.Flow, error) {uid, admin, err := validatePermission(ctx, "flows.subscribe")@@ -2730,6 +2859,48 @@ func (r *subscriptionResolver) ResourceDeleted(ctx context.Context) (<-chan *modreturn sub.ResourceDeleted(ctx)}+// KnowledgeDocumentCreated is the resolver for the knowledgeDocumentCreated field.+func (r *subscriptionResolver) KnowledgeDocumentCreated(ctx context.Context) (<-chan *model.KnowledgeDocument, error) {+ uid, admin, err := validatePermission(ctx, "knowledge.subscribe")+ if err != nil {+ return nil, err+ }++ sub := r.Subscriptions.NewKnowledgeSubscriber(uid)+ if admin {+ return sub.KnowledgeDocumentCreatedAdmin(ctx)+ }+ return sub.KnowledgeDocumentCreated(ctx)+}++// KnowledgeDocumentUpdated is the resolver for the knowledgeDocumentUpdated field.+func (r *subscriptionResolver) KnowledgeDocumentUpdated(ctx context.Context) (<-chan *model.KnowledgeDocument, error) {+ uid, admin, err := validatePermission(ctx, "knowledge.subscribe")+ if err != nil {+ return nil, err+ }++ sub := r.Subscriptions.NewKnowledgeSubscriber(uid)+ if admin {+ return sub.KnowledgeDocumentUpdatedAdmin(ctx)+ }+ return sub.KnowledgeDocumentUpdated(ctx)+}++// KnowledgeDocumentDeleted is the resolver for the knowledgeDocumentDeleted field.+func (r *subscriptionResolver) KnowledgeDocumentDeleted(ctx context.Context) (<-chan *model.KnowledgeDocument, error) {+ uid, admin, err := validatePermission(ctx, "knowledge.subscribe")+ if err != nil {+ return nil, err+ }++ sub := r.Subscriptions.NewKnowledgeSubscriber(uid)+ if admin {+ return sub.KnowledgeDocumentDeletedAdmin(ctx)+ }+ return sub.KnowledgeDocumentDeleted(ctx)+}+// Mutation returns MutationResolver implementation.func (r *Resolver) Mutation() MutationResolver { return &mutationResolver{r} }diff --git a/backend/pkg/graph/subscriptions/controller.go b/backend/pkg/graph/subscriptions/controller.goindex fb542867..ff10e3c6 100644--- a/backend/pkg/graph/subscriptions/controller.go+++ b/backend/pkg/graph/subscriptions/controller.go@@ -28,6 +28,8 @@ type SubscriptionsController interface {NewSettingsPublisher(userID int64) SettingsPublisherNewFlowTemplateSubscriber(userID int64) FlowTemplateSubscriberNewFlowTemplatePublisher(userID int64) FlowTemplatePublisher+ NewKnowledgeSubscriber(userID int64) KnowledgeSubscriber+ NewKnowledgePublisher(userID int64) KnowledgePublisher}type UserContext interface {@@ -125,10 +127,33 @@ type FlowPublisher interface {VectorStoreLogAdded(ctx context.Context, vectorStoreLog database.Vecstorelog)AssistantLogAdded(ctx context.Context, assistantLog database.Assistantlog)AssistantLogUpdated(ctx context.Context, assistantLog database.Assistantlog, appendPart bool)+ KnowledgeDocumentCreated(ctx context.Context, doc *model.KnowledgeDocument)FlowContextUserContext}+// KnowledgeSubscriber subscribes to knowledge document events.+// Regular users receive only their own events (scoped by userID via Publish).+// Admin users additionally use the Admin variants which receive all events via Broadcast.+type KnowledgeSubscriber interface {+ KnowledgeDocumentCreated(ctx context.Context) (<-chan *model.KnowledgeDocument, error)+ KnowledgeDocumentUpdated(ctx context.Context) (<-chan *model.KnowledgeDocument, error)+ KnowledgeDocumentDeleted(ctx context.Context) (<-chan *model.KnowledgeDocument, error)+ KnowledgeDocumentCreatedAdmin(ctx context.Context) (<-chan *model.KnowledgeDocument, error)+ KnowledgeDocumentUpdatedAdmin(ctx context.Context) (<-chan *model.KnowledgeDocument, error)+ KnowledgeDocumentDeletedAdmin(ctx context.Context) (<-chan *model.KnowledgeDocument, error)+ UserContext+}++// KnowledgePublisher publishes knowledge document events.+// Regular events are scoped by userID (Publish); admin channels receive all via Broadcast.+type KnowledgePublisher interface {+ KnowledgeDocumentCreated(ctx context.Context, doc *model.KnowledgeDocument)+ KnowledgeDocumentUpdated(ctx context.Context, doc *model.KnowledgeDocument)+ KnowledgeDocumentDeleted(ctx context.Context, doc *model.KnowledgeDocument)+ UserContext+}+type ProviderPublisher interface {ProviderCreated(ctx context.Context, provider database.Provider, cfg *pconfig.ProviderConfig)ProviderUpdated(ctx context.Context, provider database.Provider, cfg *pconfig.ProviderConfig)@@ -163,88 +188,112 @@ type ResourcePublisher interface {}type controller struct {- flowCreatedAdmin Channel[*model.Flow]- flowCreated Channel[*model.Flow]- flowDeletedAdmin Channel[*model.Flow]- flowDeleted Channel[*model.Flow]- flowUpdatedAdmin Channel[*model.Flow]- flowUpdated Channel[*model.Flow]- taskCreated Channel[*model.Task]- taskUpdated Channel[*model.Task]- assistantCreated Channel[*model.Assistant]- assistantUpdated Channel[*model.Assistant]- assistantDeleted Channel[*model.Assistant]- flowFileAdded Channel[*model.FlowFile]- flowFileUpdated Channel[*model.FlowFile]- flowFileDeleted Channel[*model.FlowFile]- screenshotAdded Channel[*model.Screenshot]- terminalLogAdded Channel[*model.TerminalLog]- messageLogAdded Channel[*model.MessageLog]- messageLogUpdated Channel[*model.MessageLog]- agentLogAdded Channel[*model.AgentLog]- searchLogAdded Channel[*model.SearchLog]- vecStoreLogAdded Channel[*model.VectorStoreLog]- assistantLogAdded Channel[*model.AssistantLog]- assistantLogUpdated Channel[*model.AssistantLog]- providerCreated Channel[*model.ProviderConfig]- providerUpdated Channel[*model.ProviderConfig]- providerDeleted Channel[*model.ProviderConfig]- apiTokenCreated Channel[*model.APIToken]- apiTokenUpdated Channel[*model.APIToken]- apiTokenDeleted Channel[*model.APIToken]- settingsUserUpdated Channel[*model.UserPreferences]- flowTemplateCreated Channel[*model.FlowTemplate]- flowTemplateUpdated Channel[*model.FlowTemplate]- flowTemplateDeleted Channel[*model.FlowTemplate]+ flowCreatedAdmin Channel[*model.Flow]+ flowCreated Channel[*model.Flow]+ flowDeletedAdmin Channel[*model.Flow]+ flowDeleted Channel[*model.Flow]+ flowUpdatedAdmin Channel[*model.Flow]+ flowUpdated Channel[*model.Flow]+ taskCreated Channel[*model.Task]+ taskUpdated Channel[*model.Task]+ assistantCreated Channel[*model.Assistant]+ assistantUpdated Channel[*model.Assistant]+ assistantDeleted Channel[*model.Assistant]+ flowFileAdded Channel[*model.FlowFile]+ flowFileUpdated Channel[*model.FlowFile]+ flowFileDeleted Channel[*model.FlowFile]+ screenshotAdded Channel[*model.Screenshot]+ terminalLogAdded Channel[*model.TerminalLog]+ messageLogAdded Channel[*model.MessageLog]+ messageLogUpdated Channel[*model.MessageLog]+ agentLogAdded Channel[*model.AgentLog]+ searchLogAdded Channel[*model.SearchLog]+ vecStoreLogAdded Channel[*model.VectorStoreLog]+ assistantLogAdded Channel[*model.AssistantLog]+ assistantLogUpdated Channel[*model.AssistantLog]++ providerCreated Channel[*model.ProviderConfig]+ providerUpdated Channel[*model.ProviderConfig]+ providerDeleted Channel[*model.ProviderConfig]++ apiTokenCreated Channel[*model.APIToken]+ apiTokenUpdated Channel[*model.APIToken]+ apiTokenDeleted Channel[*model.APIToken]++ settingsUserUpdated Channel[*model.UserPreferences]++ flowTemplateCreated Channel[*model.FlowTemplate]+ flowTemplateUpdated Channel[*model.FlowTemplate]+ flowTemplateDeleted Channel[*model.FlowTemplate]+resourceAdded Channel[*model.UserResource]resourceUpdated Channel[*model.UserResource]resourceDeleted Channel[*model.UserResource]resourceAddedAdmin Channel[*model.UserResource]resourceUpdatedAdmin Channel[*model.UserResource]resourceDeletedAdmin Channel[*model.UserResource]++ knowledgeDocumentCreated Channel[*model.KnowledgeDocument]+ knowledgeDocumentUpdated Channel[*model.KnowledgeDocument]+ knowledgeDocumentDeleted Channel[*model.KnowledgeDocument]+ knowledgeDocumentCreatedAdmin Channel[*model.KnowledgeDocument]+ knowledgeDocumentUpdatedAdmin Channel[*model.KnowledgeDocument]+ knowledgeDocumentDeletedAdmin Channel[*model.KnowledgeDocument]}func NewSubscriptionsController() SubscriptionsController {return &controller{- flowCreatedAdmin: NewChannel[*model.Flow](),- flowCreated: NewChannel[*model.Flow](),- flowDeletedAdmin: NewChannel[*model.Flow](),- flowDeleted: NewChannel[*model.Flow](),- flowUpdatedAdmin: NewChannel[*model.Flow](),- flowUpdated: NewChannel[*model.Flow](),- taskCreated: NewChannel[*model.Task](),- taskUpdated: NewChannel[*model.Task](),- assistantCreated: NewChannel[*model.Assistant](),- assistantUpdated: NewChannel[*model.Assistant](),- assistantDeleted: NewChannel[*model.Assistant](),- flowFileAdded: NewChannel[*model.FlowFile](),- flowFileUpdated: NewChannel[*model.FlowFile](),- flowFileDeleted: NewChannel[*model.FlowFile](),- screenshotAdded: NewChannel[*model.Screenshot](),- terminalLogAdded: NewChannel[*model.TerminalLog](),- messageLogAdded: NewChannel[*model.MessageLog](),- messageLogUpdated: NewChannel[*model.MessageLog](),- agentLogAdded: NewChannel[*model.AgentLog](),- searchLogAdded: NewChannel[*model.SearchLog](),- vecStoreLogAdded: NewChannel[*model.VectorStoreLog](),- assistantLogAdded: NewChannel[*model.AssistantLog](),- assistantLogUpdated: NewChannel[*model.AssistantLog](),- providerCreated: NewChannel[*model.ProviderConfig](),- providerUpdated: NewChannel[*model.ProviderConfig](),- providerDeleted: NewChannel[*model.ProviderConfig](),- apiTokenCreated: NewChannel[*model.APIToken](),- apiTokenUpdated: NewChannel[*model.APIToken](),- apiTokenDeleted: NewChannel[*model.APIToken](),- settingsUserUpdated: NewChannel[*model.UserPreferences](),- flowTemplateCreated: NewChannel[*model.FlowTemplate](),- flowTemplateUpdated: NewChannel[*model.FlowTemplate](),- flowTemplateDeleted: NewChannel[*model.FlowTemplate](),+ flowCreatedAdmin: NewChannel[*model.Flow](),+ flowCreated: NewChannel[*model.Flow](),+ flowDeletedAdmin: NewChannel[*model.Flow](),+ flowDeleted: NewChannel[*model.Flow](),+ flowUpdatedAdmin: NewChannel[*model.Flow](),+ flowUpdated: NewChannel[*model.Flow](),+ taskCreated: NewChannel[*model.Task](),+ taskUpdated: NewChannel[*model.Task](),+ assistantCreated: NewChannel[*model.Assistant](),+ assistantUpdated: NewChannel[*model.Assistant](),+ assistantDeleted: NewChannel[*model.Assistant](),+ flowFileAdded: NewChannel[*model.FlowFile](),+ flowFileUpdated: NewChannel[*model.FlowFile](),+ flowFileDeleted: NewChannel[*model.FlowFile](),+ screenshotAdded: NewChannel[*model.Screenshot](),+ terminalLogAdded: NewChannel[*model.TerminalLog](),+ messageLogAdded: NewChannel[*model.MessageLog](),+ messageLogUpdated: NewChannel[*model.MessageLog](),+ agentLogAdded: NewChannel[*model.AgentLog](),+ searchLogAdded: NewChannel[*model.SearchLog](),+ vecStoreLogAdded: NewChannel[*model.VectorStoreLog](),+ assistantLogAdded: NewChannel[*model.AssistantLog](),+ assistantLogUpdated: NewChannel[*model.AssistantLog](),++ providerCreated: NewChannel[*model.ProviderConfig](),+ providerUpdated: NewChannel[*model.ProviderConfig](),+ providerDeleted: NewChannel[*model.ProviderConfig](),++ apiTokenCreated: NewChannel[*model.APIToken](),+ apiTokenUpdated: NewChannel[*model.APIToken](),+ apiTokenDeleted: NewChannel[*model.APIToken](),++ settingsUserUpdated: NewChannel[*model.UserPreferences](),++ flowTemplateCreated: NewChannel[*model.FlowTemplate](),+ flowTemplateUpdated: NewChannel[*model.FlowTemplate](),+ flowTemplateDeleted: NewChannel[*model.FlowTemplate](),+resourceAdded: NewChannel[*model.UserResource](),resourceUpdated: NewChannel[*model.UserResource](),resourceDeleted: NewChannel[*model.UserResource](),resourceAddedAdmin: NewChannel[*model.UserResource](),resourceUpdatedAdmin: NewChannel[*model.UserResource](),resourceDeletedAdmin: NewChannel[*model.UserResource](),++ knowledgeDocumentCreated: NewChannel[*model.KnowledgeDocument](),+ knowledgeDocumentUpdated: NewChannel[*model.KnowledgeDocument](),+ knowledgeDocumentDeleted: NewChannel[*model.KnowledgeDocument](),+ knowledgeDocumentCreatedAdmin: NewChannel[*model.KnowledgeDocument](),+ knowledgeDocumentUpdatedAdmin: NewChannel[*model.KnowledgeDocument](),+ knowledgeDocumentDeletedAdmin: NewChannel[*model.KnowledgeDocument](),}}@@ -310,6 +359,14 @@ func (s *controller) NewFlowTemplateSubscriber(userID int64) FlowTemplateSubscrireturn &flowTemplateSubscriber{userID: userID, ctrl: s}}+func (s *controller) NewKnowledgePublisher(userID int64) KnowledgePublisher {+ return &knowledgePublisher{userID: userID, ctrl: s}+}++func (s *controller) NewKnowledgeSubscriber(userID int64) KnowledgeSubscriber {+ return &knowledgeSubscriber{userID: userID, ctrl: s}+}+type Channel[T any] interface {Subscribe(ctx context.Context, id int64) <-chan TPublish(ctx context.Context, id int64, data T)diff --git a/backend/pkg/graph/subscriptions/publisher.go b/backend/pkg/graph/subscriptions/publisher.goindex 1fcfcce0..1aa6e8f1 100644--- a/backend/pkg/graph/subscriptions/publisher.go+++ b/backend/pkg/graph/subscriptions/publisher.go@@ -117,6 +117,11 @@ func (p *flowPublisher) AssistantLogUpdated(ctx context.Context, assistantLog dap.ctrl.assistantLogUpdated.Publish(ctx, p.flowID, converter.ConvertAssistantLog(assistantLog, appendPart))}+func (p *flowPublisher) KnowledgeDocumentCreated(ctx context.Context, doc *model.KnowledgeDocument) {+ p.ctrl.knowledgeDocumentCreated.Publish(ctx, p.userID, doc)+ p.ctrl.knowledgeDocumentCreatedAdmin.Broadcast(ctx, doc)+}+// providerPublisher publishes user-scoped provider events.type providerPublisher struct {userID int64@@ -241,3 +246,32 @@ func (p *resourcePublisher) ResourceDeleted(ctx context.Context, resource *modelp.ctrl.resourceDeleted.Publish(ctx, p.userID, resource)p.ctrl.resourceDeletedAdmin.Broadcast(ctx, resource)}++// knowledgePublisher publishes knowledge document events scoped to userID and broadcasts to admins.+type knowledgePublisher struct {+ userID int64+ ctrl *controller+}++func (p *knowledgePublisher) GetUserID() int64 {+ return p.userID+}++func (p *knowledgePublisher) SetUserID(userID int64) {+ p.userID = userID+}++func (p *knowledgePublisher) KnowledgeDocumentCreated(ctx context.Context, doc *model.KnowledgeDocument) {+ p.ctrl.knowledgeDocumentCreated.Publish(ctx, p.userID, doc)+ p.ctrl.knowledgeDocumentCreatedAdmin.Broadcast(ctx, doc)+}++func (p *knowledgePublisher) KnowledgeDocumentUpdated(ctx context.Context, doc *model.KnowledgeDocument) {+ p.ctrl.knowledgeDocumentUpdated.Publish(ctx, p.userID, doc)+ p.ctrl.knowledgeDocumentUpdatedAdmin.Broadcast(ctx, doc)+}++func (p *knowledgePublisher) KnowledgeDocumentDeleted(ctx context.Context, doc *model.KnowledgeDocument) {+ p.ctrl.knowledgeDocumentDeleted.Publish(ctx, p.userID, doc)+ p.ctrl.knowledgeDocumentDeletedAdmin.Broadcast(ctx, doc)+}diff --git a/backend/pkg/graph/subscriptions/subscriber.go b/backend/pkg/graph/subscriptions/subscriber.goindex aa4a4827..7293eab4 100644--- a/backend/pkg/graph/subscriptions/subscriber.go+++ b/backend/pkg/graph/subscriptions/subscriber.go@@ -253,3 +253,41 @@ func (s *resourceSubscriber) ResourceUpdatedAdmin(ctx context.Context) (<-chan *func (s *resourceSubscriber) ResourceDeletedAdmin(ctx context.Context) (<-chan *model.UserResource, error) {return s.ctrl.resourceDeletedAdmin.Subscribe(ctx, s.userID), nil}++// knowledgeSubscriber subscribes to global knowledge document events (broadcast to all users).+type knowledgeSubscriber struct {+ userID int64+ ctrl *controller+}++func (s *knowledgeSubscriber) GetUserID() int64 {+ return s.userID+}++func (s *knowledgeSubscriber) SetUserID(userID int64) {+ s.userID = userID+}++func (s *knowledgeSubscriber) KnowledgeDocumentCreated(ctx context.Context) (<-chan *model.KnowledgeDocument, error) {+ return s.ctrl.knowledgeDocumentCreated.Subscribe(ctx, s.userID), nil+}++func (s *knowledgeSubscriber) KnowledgeDocumentUpdated(ctx context.Context) (<-chan *model.KnowledgeDocument, error) {+ return s.ctrl.knowledgeDocumentUpdated.Subscribe(ctx, s.userID), nil+}++func (s *knowledgeSubscriber) KnowledgeDocumentDeleted(ctx context.Context) (<-chan *model.KnowledgeDocument, error) {+ return s.ctrl.knowledgeDocumentDeleted.Subscribe(ctx, s.userID), nil+}++func (s *knowledgeSubscriber) KnowledgeDocumentCreatedAdmin(ctx context.Context) (<-chan *model.KnowledgeDocument, error) {+ return s.ctrl.knowledgeDocumentCreatedAdmin.Subscribe(ctx, s.userID), nil+}++func (s *knowledgeSubscriber) KnowledgeDocumentUpdatedAdmin(ctx context.Context) (<-chan *model.KnowledgeDocument, error) {+ return s.ctrl.knowledgeDocumentUpdatedAdmin.Subscribe(ctx, s.userID), nil+}++func (s *knowledgeSubscriber) KnowledgeDocumentDeletedAdmin(ctx context.Context) (<-chan *model.KnowledgeDocument, error) {+ return s.ctrl.knowledgeDocumentDeletedAdmin.Subscribe(ctx, s.userID), nil+}diff --git a/backend/pkg/server/docs/docs.go b/backend/pkg/server/docs/docs.goindex a3e87ccc..8840f7b2 100644--- a/backend/pkg/server/docs/docs.go+++ b/backend/pkg/server/docs/docs.go@@ -4124,6 +4124,470 @@ const docTemplate = `{}}},+ "/knowledge/": {+ "get": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "Knowledge"+ ],+ "summary": "List knowledge documents",+ "parameters": [+ {+ "type": "array",+ "items": {+ "type": "string"+ },+ "collectionFormat": "multi",+ "description": "Filtering result on server e.g. {\"value\":[...],\"field\":\"...\",\"operator\":\"...\"}\n field is the unique identifier of the table column, different for each endpoint\n value should be integer or string or array type, \"value\":123 or \"value\":\"string\" or \"value\":[123,456]\n operator value should be one of \u003c,\u003c=,\u003e=,\u003e,=,!=,like,not like,in\n default operator value is 'like' or '=' if field is 'id' or '*_id' or '*_at'",+ "name": "filters[]",+ "in": "query"+ },+ {+ "type": "string",+ "description": "Field to group results by",+ "name": "group",+ "in": "query"+ },+ {+ "minimum": 1,+ "type": "integer",+ "default": 1,+ "description": "Number of page (since 1)",+ "name": "page",+ "in": "query",+ "required": true+ },+ {+ "maximum": 1000,+ "minimum": -1,+ "type": "integer",+ "default": 5,+ "description": "Amount items per page (min -1, max 1000, -1 means unlimited)",+ "name": "pageSize",+ "in": "query"+ },+ {+ "type": "array",+ "items": {+ "type": "string"+ },+ "collectionFormat": "multi",+ "description": "Sorting result on server e.g. {\"prop\":\"...\",\"order\":\"...\"}\n field order is \"ascending\" or \"descending\" value\n order is required if prop is not empty",+ "name": "sort[]",+ "in": "query"+ },+ {+ "enum": [+ "sort",+ "filter",+ "init",+ "page",+ "size"+ ],+ "type": "string",+ "default": "init",+ "description": "Type of request",+ "name": "type",+ "in": "query",+ "required": true+ },+ {+ "type": "boolean",+ "description": "include document text in the response",+ "name": "with_content",+ "in": "query"+ }+ ],+ "responses": {+ "200": {+ "description": "OK",+ "schema": {+ "allOf": [+ {+ "$ref": "#/definitions/SuccessResponse"+ },+ {+ "type": "object",+ "properties": {+ "data": {+ "$ref": "#/definitions/models.KnowledgeDocList"+ }+ }+ }+ ]+ }+ },+ "400": {+ "description": "invalid query parameters",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "403": {+ "description": "not permitted",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "500": {+ "description": "internal error",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ }+ }+ },+ "post": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "consumes": [+ "application/json"+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "Knowledge"+ ],+ "summary": "Create knowledge document",+ "parameters": [+ {+ "description": "Create request",+ "name": "json",+ "in": "body",+ "required": true,+ "schema": {+ "$ref": "#/definitions/models.CreateKnowledgeDocRequest"+ }+ }+ ],+ "responses": {+ "201": {+ "description": "Created",+ "schema": {+ "allOf": [+ {+ "$ref": "#/definitions/SuccessResponse"+ },+ {+ "type": "object",+ "properties": {+ "data": {+ "$ref": "#/definitions/models.KnowledgeDocEntry"+ }+ }+ }+ ]+ }+ },+ "400": {+ "description": "invalid request",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "403": {+ "description": "not permitted",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "500": {+ "description": "internal error",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "503": {+ "description": "embedding provider not configured",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ }+ }+ }+ },+ "/knowledge/search": {+ "post": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "consumes": [+ "application/json"+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "Knowledge"+ ],+ "summary": "Semantic search in knowledge base",+ "parameters": [+ {+ "description": "Search request",+ "name": "json",+ "in": "body",+ "required": true,+ "schema": {+ "$ref": "#/definitions/models.KnowledgeSearchRequest"+ }+ }+ ],+ "responses": {+ "200": {+ "description": "OK",+ "schema": {+ "allOf": [+ {+ "$ref": "#/definitions/SuccessResponse"+ },+ {+ "type": "object",+ "properties": {+ "data": {+ "$ref": "#/definitions/models.KnowledgeSearchResult"+ }+ }+ }+ ]+ }+ },+ "400": {+ "description": "invalid request",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "403": {+ "description": "not permitted",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "500": {+ "description": "internal error",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "503": {+ "description": "embedding provider not configured",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ }+ }+ }+ },+ "/knowledge/{id}": {+ "get": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "Knowledge"+ ],+ "summary": "Get knowledge document",+ "parameters": [+ {+ "type": "string",+ "description": "Document UUID",+ "name": "id",+ "in": "path",+ "required": true+ }+ ],+ "responses": {+ "200": {+ "description": "OK",+ "schema": {+ "allOf": [+ {+ "$ref": "#/definitions/SuccessResponse"+ },+ {+ "type": "object",+ "properties": {+ "data": {+ "$ref": "#/definitions/models.KnowledgeDocEntry"+ }+ }+ }+ ]+ }+ },+ "403": {+ "description": "not permitted or wrong owner",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "404": {+ "description": "document not found",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "500": {+ "description": "internal error",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ }+ }+ },+ "put": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "consumes": [+ "application/json"+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "Knowledge"+ ],+ "summary": "Update knowledge document",+ "parameters": [+ {+ "type": "string",+ "description": "Document UUID",+ "name": "id",+ "in": "path",+ "required": true+ },+ {+ "description": "Update request",+ "name": "json",+ "in": "body",+ "required": true,+ "schema": {+ "$ref": "#/definitions/models.UpdateKnowledgeDocRequest"+ }+ }+ ],+ "responses": {+ "200": {+ "description": "OK",+ "schema": {+ "allOf": [+ {+ "$ref": "#/definitions/SuccessResponse"+ },+ {+ "type": "object",+ "properties": {+ "data": {+ "$ref": "#/definitions/models.KnowledgeDocEntry"+ }+ }+ }+ ]+ }+ },+ "400": {+ "description": "invalid request",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "403": {+ "description": "not permitted or wrong owner",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "404": {+ "description": "document not found",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "500": {+ "description": "internal error",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "503": {+ "description": "embedding provider not configured",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ }+ }+ },+ "delete": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "Knowledge"+ ],+ "summary": "Delete knowledge document",+ "parameters": [+ {+ "type": "string",+ "description": "Document UUID",+ "name": "id",+ "in": "path",+ "required": true+ }+ ],+ "responses": {+ "200": {+ "description": "document deleted",+ "schema": {+ "$ref": "#/definitions/SuccessResponse"+ }+ },+ "403": {+ "description": "not permitted or wrong owner",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "404": {+ "description": "document not found",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "500": {+ "description": "internal error",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ }+ }+ }+ },"/msglogs/": {"get": {"security": [@@ -7435,6 +7899,43 @@ const docTemplate = `{}}},+ "models.CreateKnowledgeDocRequest": {+ "type": "object",+ "required": [+ "content",+ "doc_type",+ "question"+ ],+ "properties": {+ "answer_type": {+ "type": "string"+ },+ "code_lang": {+ "type": "string",+ "maxLength": 100+ },+ "content": {+ "type": "string",+ "maxLength": 65536,+ "minLength": 1+ },+ "description": {+ "type": "string",+ "maxLength": 1000+ },+ "doc_type": {+ "type": "string"+ },+ "guide_type": {+ "type": "string"+ },+ "question": {+ "type": "string",+ "maxLength": 2048,+ "minLength": 1+ }+ }+ },"models.DailyFlowsStats": {"type": "object","required": [@@ -7787,6 +8288,143 @@ const docTemplate = `{}}},+ "models.KnowledgeDocEntry": {+ "type": "object",+ "properties": {+ "answer_type": {+ "type": "string"+ },+ "code_lang": {+ "type": "string"+ },+ "content": {+ "type": "string"+ },+ "description": {+ "type": "string"+ },+ "doc_type": {+ "type": "string"+ },+ "flow_id": {+ "type": "integer"+ },+ "guide_type": {+ "type": "string"+ },+ "id": {+ "type": "string"+ },+ "manual": {+ "type": "boolean"+ },+ "part_size": {+ "type": "integer"+ },+ "question": {+ "type": "string"+ },+ "subtask_id": {+ "type": "integer"+ },+ "task_id": {+ "type": "integer"+ },+ "total_size": {+ "type": "integer"+ },+ "user_id": {+ "type": "integer"+ }+ }+ },+ "models.KnowledgeDocList": {+ "type": "object",+ "properties": {+ "items": {+ "type": "array",+ "items": {+ "$ref": "#/definitions/models.KnowledgeDocEntry"+ }+ },+ "total": {+ "type": "integer"+ }+ }+ },+ "models.KnowledgeDocWithScore": {+ "type": "object",+ "properties": {+ "document": {+ "$ref": "#/definitions/models.KnowledgeDocEntry"+ },+ "score": {+ "type": "number"+ }+ }+ },+ "models.KnowledgeSearchRequest": {+ "type": "object",+ "required": [+ "query"+ ],+ "properties": {+ "answer_types": {+ "type": "array",+ "items": {+ "type": "string"+ }+ },+ "code_langs": {+ "type": "array",+ "items": {+ "type": "string"+ }+ },+ "doc_types": {+ "type": "array",+ "items": {+ "type": "string"+ }+ },+ "flow_id": {+ "type": "integer"+ },+ "guide_types": {+ "type": "array",+ "items": {+ "type": "string"+ }+ },+ "limit": {+ "type": "integer",+ "maximum": 100,+ "minimum": 1+ },+ "manual": {+ "type": "boolean"+ },+ "query": {+ "type": "string",+ "maxLength": 2048,+ "minLength": 1+ }+ }+ },+ "models.KnowledgeSearchResult": {+ "type": "object",+ "properties": {+ "items": {+ "type": "array",+ "items": {+ "$ref": "#/definitions/models.KnowledgeDocWithScore"+ }+ },+ "total": {+ "type": "integer"+ }+ }+ },"models.Login": {"type": "object","required": [@@ -8575,6 +9213,38 @@ const docTemplate = `{}}},+ "models.UpdateKnowledgeDocRequest": {+ "type": "object",+ "required": [+ "content"+ ],+ "properties": {+ "answer_type": {+ "type": "string"+ },+ "code_lang": {+ "type": "string",+ "maxLength": 100+ },+ "content": {+ "type": "string",+ "maxLength": 65536,+ "minLength": 1+ },+ "description": {+ "type": "string",+ "maxLength": 1000+ },+ "guide_type": {+ "type": "string"+ },+ "question": {+ "type": "string",+ "maxLength": 2048,+ "minLength": 1+ }+ }+ },"models.UsageStats": {"type": "object","properties": {diff --git a/backend/pkg/server/docs/swagger.json b/backend/pkg/server/docs/swagger.jsonindex 3114fb74..2b5dc920 100644--- a/backend/pkg/server/docs/swagger.json+++ b/backend/pkg/server/docs/swagger.json@@ -4116,6 +4116,470 @@}}},+ "/knowledge/": {+ "get": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "Knowledge"+ ],+ "summary": "List knowledge documents",+ "parameters": [+ {+ "type": "array",+ "items": {+ "type": "string"+ },+ "collectionFormat": "multi",+ "description": "Filtering result on server e.g. {\"value\":[...],\"field\":\"...\",\"operator\":\"...\"}\n field is the unique identifier of the table column, different for each endpoint\n value should be integer or string or array type, \"value\":123 or \"value\":\"string\" or \"value\":[123,456]\n operator value should be one of \u003c,\u003c=,\u003e=,\u003e,=,!=,like,not like,in\n default operator value is 'like' or '=' if field is 'id' or '*_id' or '*_at'",+ "name": "filters[]",+ "in": "query"+ },+ {+ "type": "string",+ "description": "Field to group results by",+ "name": "group",+ "in": "query"+ },+ {+ "minimum": 1,+ "type": "integer",+ "default": 1,+ "description": "Number of page (since 1)",+ "name": "page",+ "in": "query",+ "required": true+ },+ {+ "maximum": 1000,+ "minimum": -1,+ "type": "integer",+ "default": 5,+ "description": "Amount items per page (min -1, max 1000, -1 means unlimited)",+ "name": "pageSize",+ "in": "query"+ },+ {+ "type": "array",+ "items": {+ "type": "string"+ },+ "collectionFormat": "multi",+ "description": "Sorting result on server e.g. {\"prop\":\"...\",\"order\":\"...\"}\n field order is \"ascending\" or \"descending\" value\n order is required if prop is not empty",+ "name": "sort[]",+ "in": "query"+ },+ {+ "enum": [+ "sort",+ "filter",+ "init",+ "page",+ "size"+ ],+ "type": "string",+ "default": "init",+ "description": "Type of request",+ "name": "type",+ "in": "query",+ "required": true+ },+ {+ "type": "boolean",+ "description": "include document text in the response",+ "name": "with_content",+ "in": "query"+ }+ ],+ "responses": {+ "200": {+ "description": "OK",+ "schema": {+ "allOf": [+ {+ "$ref": "#/definitions/SuccessResponse"+ },+ {+ "type": "object",+ "properties": {+ "data": {+ "$ref": "#/definitions/models.KnowledgeDocList"+ }+ }+ }+ ]+ }+ },+ "400": {+ "description": "invalid query parameters",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "403": {+ "description": "not permitted",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "500": {+ "description": "internal error",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ }+ }+ },+ "post": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "consumes": [+ "application/json"+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "Knowledge"+ ],+ "summary": "Create knowledge document",+ "parameters": [+ {+ "description": "Create request",+ "name": "json",+ "in": "body",+ "required": true,+ "schema": {+ "$ref": "#/definitions/models.CreateKnowledgeDocRequest"+ }+ }+ ],+ "responses": {+ "201": {+ "description": "Created",+ "schema": {+ "allOf": [+ {+ "$ref": "#/definitions/SuccessResponse"+ },+ {+ "type": "object",+ "properties": {+ "data": {+ "$ref": "#/definitions/models.KnowledgeDocEntry"+ }+ }+ }+ ]+ }+ },+ "400": {+ "description": "invalid request",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "403": {+ "description": "not permitted",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "500": {+ "description": "internal error",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "503": {+ "description": "embedding provider not configured",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ }+ }+ }+ },+ "/knowledge/search": {+ "post": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "consumes": [+ "application/json"+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "Knowledge"+ ],+ "summary": "Semantic search in knowledge base",+ "parameters": [+ {+ "description": "Search request",+ "name": "json",+ "in": "body",+ "required": true,+ "schema": {+ "$ref": "#/definitions/models.KnowledgeSearchRequest"+ }+ }+ ],+ "responses": {+ "200": {+ "description": "OK",+ "schema": {+ "allOf": [+ {+ "$ref": "#/definitions/SuccessResponse"+ },+ {+ "type": "object",+ "properties": {+ "data": {+ "$ref": "#/definitions/models.KnowledgeSearchResult"+ }+ }+ }+ ]+ }+ },+ "400": {+ "description": "invalid request",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "403": {+ "description": "not permitted",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "500": {+ "description": "internal error",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "503": {+ "description": "embedding provider not configured",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ }+ }+ }+ },+ "/knowledge/{id}": {+ "get": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "Knowledge"+ ],+ "summary": "Get knowledge document",+ "parameters": [+ {+ "type": "string",+ "description": "Document UUID",+ "name": "id",+ "in": "path",+ "required": true+ }+ ],+ "responses": {+ "200": {+ "description": "OK",+ "schema": {+ "allOf": [+ {+ "$ref": "#/definitions/SuccessResponse"+ },+ {+ "type": "object",+ "properties": {+ "data": {+ "$ref": "#/definitions/models.KnowledgeDocEntry"+ }+ }+ }+ ]+ }+ },+ "403": {+ "description": "not permitted or wrong owner",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "404": {+ "description": "document not found",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "500": {+ "description": "internal error",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ }+ }+ },+ "put": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "consumes": [+ "application/json"+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "Knowledge"+ ],+ "summary": "Update knowledge document",+ "parameters": [+ {+ "type": "string",+ "description": "Document UUID",+ "name": "id",+ "in": "path",+ "required": true+ },+ {+ "description": "Update request",+ "name": "json",+ "in": "body",+ "required": true,+ "schema": {+ "$ref": "#/definitions/models.UpdateKnowledgeDocRequest"+ }+ }+ ],+ "responses": {+ "200": {+ "description": "OK",+ "schema": {+ "allOf": [+ {+ "$ref": "#/definitions/SuccessResponse"+ },+ {+ "type": "object",+ "properties": {+ "data": {+ "$ref": "#/definitions/models.KnowledgeDocEntry"+ }+ }+ }+ ]+ }+ },+ "400": {+ "description": "invalid request",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "403": {+ "description": "not permitted or wrong owner",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "404": {+ "description": "document not found",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "500": {+ "description": "internal error",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "503": {+ "description": "embedding provider not configured",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ }+ }+ },+ "delete": {+ "security": [+ {+ "BearerAuth": []+ }+ ],+ "produces": [+ "application/json"+ ],+ "tags": [+ "Knowledge"+ ],+ "summary": "Delete knowledge document",+ "parameters": [+ {+ "type": "string",+ "description": "Document UUID",+ "name": "id",+ "in": "path",+ "required": true+ }+ ],+ "responses": {+ "200": {+ "description": "document deleted",+ "schema": {+ "$ref": "#/definitions/SuccessResponse"+ }+ },+ "403": {+ "description": "not permitted or wrong owner",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "404": {+ "description": "document not found",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ },+ "500": {+ "description": "internal error",+ "schema": {+ "$ref": "#/definitions/ErrorResponse"+ }+ }+ }+ }+ },"/msglogs/": {"get": {"security": [@@ -7427,6 +7891,43 @@}}},+ "models.CreateKnowledgeDocRequest": {+ "type": "object",+ "required": [+ "content",+ "doc_type",+ "question"+ ],+ "properties": {+ "answer_type": {+ "type": "string"+ },+ "code_lang": {+ "type": "string",+ "maxLength": 100+ },+ "content": {+ "type": "string",+ "maxLength": 65536,+ "minLength": 1+ },+ "description": {+ "type": "string",+ "maxLength": 1000+ },+ "doc_type": {+ "type": "string"+ },+ "guide_type": {+ "type": "string"+ },+ "question": {+ "type": "string",+ "maxLength": 2048,+ "minLength": 1+ }+ }+ },"models.DailyFlowsStats": {"type": "object","required": [@@ -7779,6 +8280,143 @@}}},+ "models.KnowledgeDocEntry": {+ "type": "object",+ "properties": {+ "answer_type": {+ "type": "string"+ },+ "code_lang": {+ "type": "string"+ },+ "content": {+ "type": "string"+ },+ "description": {+ "type": "string"+ },+ "doc_type": {+ "type": "string"+ },+ "flow_id": {+ "type": "integer"+ },+ "guide_type": {+ "type": "string"+ },+ "id": {+ "type": "string"+ },+ "manual": {+ "type": "boolean"+ },+ "part_size": {+ "type": "integer"+ },+ "question": {+ "type": "string"+ },+ "subtask_id": {+ "type": "integer"+ },+ "task_id": {+ "type": "integer"+ },+ "total_size": {+ "type": "integer"+ },+ "user_id": {+ "type": "integer"+ }+ }+ },+ "models.KnowledgeDocList": {+ "type": "object",+ "properties": {+ "items": {+ "type": "array",+ "items": {+ "$ref": "#/definitions/models.KnowledgeDocEntry"+ }+ },+ "total": {+ "type": "integer"+ }+ }+ },+ "models.KnowledgeDocWithScore": {+ "type": "object",+ "properties": {+ "document": {+ "$ref": "#/definitions/models.KnowledgeDocEntry"+ },+ "score": {+ "type": "number"+ }+ }+ },+ "models.KnowledgeSearchRequest": {+ "type": "object",+ "required": [+ "query"+ ],+ "properties": {+ "answer_types": {+ "type": "array",+ "items": {+ "type": "string"+ }+ },+ "code_langs": {+ "type": "array",+ "items": {+ "type": "string"+ }+ },+ "doc_types": {+ "type": "array",+ "items": {+ "type": "string"+ }+ },+ "flow_id": {+ "type": "integer"+ },+ "guide_types": {+ "type": "array",+ "items": {+ "type": "string"+ }+ },+ "limit": {+ "type": "integer",+ "maximum": 100,+ "minimum": 1+ },+ "manual": {+ "type": "boolean"+ },+ "query": {+ "type": "string",+ "maxLength": 2048,+ "minLength": 1+ }+ }+ },+ "models.KnowledgeSearchResult": {+ "type": "object",+ "properties": {+ "items": {+ "type": "array",+ "items": {+ "$ref": "#/definitions/models.KnowledgeDocWithScore"+ }+ },+ "total": {+ "type": "integer"+ }+ }+ },"models.Login": {"type": "object","required": [@@ -8567,6 +9205,38 @@}}},+ "models.UpdateKnowledgeDocRequest": {+ "type": "object",+ "required": [+ "content"+ ],+ "properties": {+ "answer_type": {+ "type": "string"+ },+ "code_lang": {+ "type": "string",+ "maxLength": 100+ },+ "content": {+ "type": "string",+ "maxLength": 65536,+ "minLength": 1+ },+ "description": {+ "type": "string",+ "maxLength": 1000+ },+ "guide_type": {+ "type": "string"+ },+ "question": {+ "type": "string",+ "maxLength": 2048,+ "minLength": 1+ }+ }+ },"models.UsageStats": {"type": "object","properties": {diff --git a/backend/pkg/server/docs/swagger.yaml b/backend/pkg/server/docs/swagger.yamlindex ddbcf48a..7e2cf2b6 100644--- a/backend/pkg/server/docs/swagger.yaml+++ b/backend/pkg/server/docs/swagger.yaml@@ -510,6 +510,33 @@ definitions:- input- providertype: object+ models.CreateKnowledgeDocRequest:+ properties:+ answer_type:+ type: string+ code_lang:+ maxLength: 100+ type: string+ content:+ maxLength: 65536+ minLength: 1+ type: string+ description:+ maxLength: 1000+ type: string+ doc_type:+ type: string+ guide_type:+ type: string+ question:+ maxLength: 2048+ minLength: 1+ type: string+ required:+ - content+ - doc_type+ - question+ type: objectmodels.DailyFlowsStats:properties:date:@@ -758,6 +785,97 @@ definitions:required:- function_nametype: object+ models.KnowledgeDocEntry:+ properties:+ answer_type:+ type: string+ code_lang:+ type: string+ content:+ type: string+ description:+ type: string+ doc_type:+ type: string+ flow_id:+ type: integer+ guide_type:+ type: string+ id:+ type: string+ manual:+ type: boolean+ part_size:+ type: integer+ question:+ type: string+ subtask_id:+ type: integer+ task_id:+ type: integer+ total_size:+ type: integer+ user_id:+ type: integer+ type: object+ models.KnowledgeDocList:+ properties:+ items:+ items:+ $ref: '#/definitions/models.KnowledgeDocEntry'+ type: array+ total:+ type: integer+ type: object+ models.KnowledgeDocWithScore:+ properties:+ document:+ $ref: '#/definitions/models.KnowledgeDocEntry'+ score:+ type: number+ type: object+ models.KnowledgeSearchRequest:+ properties:+ answer_types:+ items:+ type: string+ type: array+ code_langs:+ items:+ type: string+ type: array+ doc_types:+ items:+ type: string+ type: array+ flow_id:+ type: integer+ guide_types:+ items:+ type: string+ type: array+ limit:+ maximum: 100+ minimum: 1+ type: integer+ manual:+ type: boolean+ query:+ maxLength: 2048+ minLength: 1+ type: string+ required:+ - query+ type: object+ models.KnowledgeSearchResult:+ properties:+ items:+ items:+ $ref: '#/definitions/models.KnowledgeDocWithScore'+ type: array+ total:+ type: integer+ type: objectmodels.Login:properties:mail:@@ -1308,6 +1426,29 @@ definitions:status:type: stringtype: object+ models.UpdateKnowledgeDocRequest:+ properties:+ answer_type:+ type: string+ code_lang:+ maxLength: 100+ type: string+ content:+ maxLength: 65536+ minLength: 1+ type: string+ description:+ maxLength: 1000+ type: string+ guide_type:+ type: string+ question:+ maxLength: 2048+ minLength: 1+ type: string+ required:+ - content+ type: objectmodels.UsageStats:properties:total_usage_cache_in:@@ -4494,6 +4635,301 @@ paths:summary: Retrieve current user and system settingstags:- Public+ /knowledge/:+ get:+ parameters:+ - collectionFormat: multi+ description: |-+ Filtering result on server e.g. {"value":[...],"field":"...","operator":"..."}+ field is the unique identifier of the table column, different for each endpoint+ value should be integer or string or array type, "value":123 or "value":"string" or "value":[123,456]+ operator value should be one of <,<=,>=,>,=,!=,like,not like,in+ default operator value is 'like' or '=' if field is 'id' or '*_id' or '*_at'+ in: query+ items:+ type: string+ name: filters[]+ type: array+ - description: Field to group results by+ in: query+ name: group+ type: string+ - default: 1+ description: Number of page (since 1)+ in: query+ minimum: 1+ name: page+ required: true+ type: integer+ - default: 5+ description: Amount items per page (min -1, max 1000, -1 means unlimited)+ in: query+ maximum: 1000+ minimum: -1+ name: pageSize+ type: integer+ - collectionFormat: multi+ description: |-+ Sorting result on server e.g. {"prop":"...","order":"..."}+ field order is "ascending" or "descending" value+ order is required if prop is not empty+ in: query+ items:+ type: string+ name: sort[]+ type: array+ - default: init+ description: Type of request+ enum:+ - sort+ - filter+ - init+ - page+ - size+ in: query+ name: type+ required: true+ type: string+ - description: include document text in the response+ in: query+ name: with_content+ type: boolean+ produces:+ - application/json+ responses:+ "200":+ description: OK+ schema:+ allOf:+ - $ref: '#/definitions/SuccessResponse'+ - properties:+ data:+ $ref: '#/definitions/models.KnowledgeDocList'+ type: object+ "400":+ description: invalid query parameters+ schema:+ $ref: '#/definitions/ErrorResponse'+ "403":+ description: not permitted+ schema:+ $ref: '#/definitions/ErrorResponse'+ "500":+ description: internal error+ schema:+ $ref: '#/definitions/ErrorResponse'+ security:+ - BearerAuth: []+ summary: List knowledge documents+ tags:+ - Knowledge+ post:+ consumes:+ - application/json+ parameters:+ - description: Create request+ in: body+ name: json+ required: true+ schema:+ $ref: '#/definitions/models.CreateKnowledgeDocRequest'+ produces:+ - application/json+ responses:+ "201":+ description: Created+ schema:+ allOf:+ - $ref: '#/definitions/SuccessResponse'+ - properties:+ data:+ $ref: '#/definitions/models.KnowledgeDocEntry'+ type: object+ "400":+ description: invalid request+ schema:+ $ref: '#/definitions/ErrorResponse'+ "403":+ description: not permitted+ schema:+ $ref: '#/definitions/ErrorResponse'+ "500":+ description: internal error+ schema:+ $ref: '#/definitions/ErrorResponse'+ "503":+ description: embedding provider not configured+ schema:+ $ref: '#/definitions/ErrorResponse'+ security:+ - BearerAuth: []+ summary: Create knowledge document+ tags:+ - Knowledge+ /knowledge/{id}:+ delete:+ parameters:+ - description: Document UUID+ in: path+ name: id+ required: true+ type: string+ produces:+ - application/json+ responses:+ "200":+ description: document deleted+ schema:+ $ref: '#/definitions/SuccessResponse'+ "403":+ description: not permitted or wrong owner+ schema:+ $ref: '#/definitions/ErrorResponse'+ "404":+ description: document not found+ schema:+ $ref: '#/definitions/ErrorResponse'+ "500":+ description: internal error+ schema:+ $ref: '#/definitions/ErrorResponse'+ security:+ - BearerAuth: []+ summary: Delete knowledge document+ tags:+ - Knowledge+ get:+ parameters:+ - description: Document UUID+ in: path+ name: id+ required: true+ type: string+ produces:+ - application/json+ responses:+ "200":+ description: OK+ schema:+ allOf:+ - $ref: '#/definitions/SuccessResponse'+ - properties:+ data:+ $ref: '#/definitions/models.KnowledgeDocEntry'+ type: object+ "403":+ description: not permitted or wrong owner+ schema:+ $ref: '#/definitions/ErrorResponse'+ "404":+ description: document not found+ schema:+ $ref: '#/definitions/ErrorResponse'+ "500":+ description: internal error+ schema:+ $ref: '#/definitions/ErrorResponse'+ security:+ - BearerAuth: []+ summary: Get knowledge document+ tags:+ - Knowledge+ put:+ consumes:+ - application/json+ parameters:+ - description: Document UUID+ in: path+ name: id+ required: true+ type: string+ - description: Update request+ in: body+ name: json+ required: true+ schema:+ $ref: '#/definitions/models.UpdateKnowledgeDocRequest'+ produces:+ - application/json+ responses:+ "200":+ description: OK+ schema:+ allOf:+ - $ref: '#/definitions/SuccessResponse'+ - properties:+ data:+ $ref: '#/definitions/models.KnowledgeDocEntry'+ type: object+ "400":+ description: invalid request+ schema:+ $ref: '#/definitions/ErrorResponse'+ "403":+ description: not permitted or wrong owner+ schema:+ $ref: '#/definitions/ErrorResponse'+ "404":+ description: document not found+ schema:+ $ref: '#/definitions/ErrorResponse'+ "500":+ description: internal error+ schema:+ $ref: '#/definitions/ErrorResponse'+ "503":+ description: embedding provider not configured+ schema:+ $ref: '#/definitions/ErrorResponse'+ security:+ - BearerAuth: []+ summary: Update knowledge document+ tags:+ - Knowledge+ /knowledge/search:+ post:+ consumes:+ - application/json+ parameters:+ - description: Search request+ in: body+ name: json+ required: true+ schema:+ $ref: '#/definitions/models.KnowledgeSearchRequest'+ produces:+ - application/json+ responses:+ "200":+ description: OK+ schema:+ allOf:+ - $ref: '#/definitions/SuccessResponse'+ - properties:+ data:+ $ref: '#/definitions/models.KnowledgeSearchResult'+ type: object+ "400":+ description: invalid request+ schema:+ $ref: '#/definitions/ErrorResponse'+ "403":+ description: not permitted+ schema:+ $ref: '#/definitions/ErrorResponse'+ "500":+ description: internal error+ schema:+ $ref: '#/definitions/ErrorResponse'+ "503":+ description: embedding provider not configured+ schema:+ $ref: '#/definitions/ErrorResponse'+ security:+ - BearerAuth: []+ summary: Semantic search in knowledge base+ tags:+ - Knowledge/msglogs/:get:parameters:diff --git a/backend/pkg/server/models/knowledge.go b/backend/pkg/server/models/knowledge.gonew file mode 100644index 00000000..76207dac--- /dev/null+++ b/backend/pkg/server/models/knowledge.go@@ -0,0 +1,476 @@+package models++import (+ "encoding/json"+ "fmt"++ gqlmodel "pentagi/pkg/graph/model"+)++// knowledgeRawMeta mirrors the flat JSON stored in langchain_pg_embedding.cmetadata.+// Used only within the models package for REST → gorm conversion.+type knowledgeRawMeta struct {+ DocType string `json:"doc_type"`+ UserID int64 `json:"user_id"`+ FlowID *int64 `json:"flow_id"`+ TaskID *int64 `json:"task_id"`+ SubtaskID *int64 `json:"subtask_id"`+ Question string `json:"question"`+ Description string `json:"description"`+ GuideType string `json:"guide_type"`+ AnswerType string `json:"answer_type"`+ CodeLang string `json:"code_lang"`+ PartSize int `json:"part_size"`+ TotalSize int `json:"total_size"`+ Manual bool `json:"manual"`+}++func knowledgeMetaFromJSON(raw string) knowledgeRawMeta {+ var m knowledgeRawMeta+ if raw != "" && raw != "{}" {+ _ = json.Unmarshal([]byte(raw), &m)+ }+ return m+}++func knowledgeMetaToEntry(id, content string, m knowledgeRawMeta) KnowledgeDocEntry {+ entry := KnowledgeDocEntry{+ ID: id,+ DocType: KnowledgeDocType(m.DocType),+ Content: content,+ Question: m.Question,+ UserID: m.UserID,+ FlowID: m.FlowID,+ TaskID: m.TaskID,+ SubtaskID: m.SubtaskID,+ PartSize: m.PartSize,+ TotalSize: m.TotalSize,+ Manual: m.Manual,+ }+ if m.Description != "" {+ d := m.Description+ entry.Description = &d+ }+ if m.GuideType != "" {+ gt := KnowledgeGuideType(m.GuideType)+ entry.GuideType = >+ }+ if m.AnswerType != "" {+ at := KnowledgeAnswerType(m.AnswerType)+ entry.AnswerType = &at+ }+ if m.CodeLang != "" {+ cl := m.CodeLang+ entry.CodeLang = &cl+ }+ return entry+}++// ==================== Enum types =============================================++// KnowledgeDocType mirrors model.KnowledgeDocType for the REST layer.+type KnowledgeDocType string++const (+ KnowledgeDocTypeAnswer KnowledgeDocType = "answer"+ KnowledgeDocTypeGuide KnowledgeDocType = "guide"+ KnowledgeDocTypeCode KnowledgeDocType = "code"+)++// Valid implements IValid.+func (t KnowledgeDocType) Valid() error {+ switch t {+ case KnowledgeDocTypeAnswer, KnowledgeDocTypeGuide, KnowledgeDocTypeCode:+ return nil+ default:+ return fmt.Errorf("invalid KnowledgeDocType: %q (expected answer|guide|code)", t)+ }+}++// KnowledgeGuideType mirrors model.KnowledgeGuideType for the REST layer.+type KnowledgeGuideType string++const (+ KnowledgeGuideTypeInstall KnowledgeGuideType = "install"+ KnowledgeGuideTypeConfigure KnowledgeGuideType = "configure"+ KnowledgeGuideTypeUse KnowledgeGuideType = "use"+ KnowledgeGuideTypePentest KnowledgeGuideType = "pentest"+ KnowledgeGuideTypeDevelopment KnowledgeGuideType = "development"+ KnowledgeGuideTypeOther KnowledgeGuideType = "other"+)++// Valid implements IValid.+func (t KnowledgeGuideType) Valid() error {+ switch t {+ case KnowledgeGuideTypeInstall,+ KnowledgeGuideTypeConfigure,+ KnowledgeGuideTypeUse,+ KnowledgeGuideTypePentest,+ KnowledgeGuideTypeDevelopment,+ KnowledgeGuideTypeOther:+ return nil+ default:+ return fmt.Errorf("invalid KnowledgeGuideType: %q", t)+ }+}++// KnowledgeAnswerType mirrors model.KnowledgeAnswerType for the REST layer.+type KnowledgeAnswerType string++const (+ KnowledgeAnswerTypeGuide KnowledgeAnswerType = "guide"+ KnowledgeAnswerTypeVulnerability KnowledgeAnswerType = "vulnerability"+ KnowledgeAnswerTypeCode KnowledgeAnswerType = "code"+ KnowledgeAnswerTypeTool KnowledgeAnswerType = "tool"+ KnowledgeAnswerTypeOther KnowledgeAnswerType = "other"+)++// Valid implements IValid.+func (t KnowledgeAnswerType) Valid() error {+ switch t {+ case KnowledgeAnswerTypeGuide,+ KnowledgeAnswerTypeVulnerability,+ KnowledgeAnswerTypeCode,+ KnowledgeAnswerTypeTool,+ KnowledgeAnswerTypeOther:+ return nil+ default:+ return fmt.Errorf("invalid KnowledgeAnswerType: %q", t)+ }+}++// ==================== Response models =========================================++// KnowledgeDocEntry is the REST response representation of a knowledge document.+//+//nolint:lll+type KnowledgeDocEntry struct {+ ID string `json:"id"`+ DocType KnowledgeDocType `json:"doc_type"`+ Content string `json:"content"`+ Question string `json:"question"`+ Description *string `json:"description,omitempty"`+ UserID int64 `json:"user_id"`+ FlowID *int64 `json:"flow_id,omitempty"`+ TaskID *int64 `json:"task_id,omitempty"`+ SubtaskID *int64 `json:"subtask_id,omitempty"`+ GuideType *KnowledgeGuideType `json:"guide_type,omitempty"`+ AnswerType *KnowledgeAnswerType `json:"answer_type,omitempty"`+ CodeLang *string `json:"code_lang,omitempty"`+ PartSize int `json:"part_size"`+ TotalSize int `json:"total_size"`+ Manual bool `json:"manual"`+}++// KnowledgeDocList is the REST list response (Total matches rdb.TableQuery return type).+type KnowledgeDocList struct {+ Items []KnowledgeDocEntry `json:"items"`+ Total uint64 `json:"total"`+}++// KnowledgeEmbeddingRow is a gorm scan target for langchain_pg_embedding rows.+// Only the columns that the knowledge API exposes are selected (no embedding vector).+type KnowledgeEmbeddingRow struct {+ ID string `gorm:"column:id"`+ Document string `gorm:"column:document"`+ Cmetadata string `gorm:"column:cmetadata"`+}++// KnowledgeDocWithScore wraps a document with its semantic similarity score.+type KnowledgeDocWithScore struct {+ Score float64 `json:"score"`+ Document KnowledgeDocEntry `json:"document"`+}++// KnowledgeSearchResult is the REST search response.+type KnowledgeSearchResult struct {+ Items []KnowledgeDocWithScore `json:"items"`+ Total int `json:"total"`+}++// ==================== Query / request models =================================++// KnowledgeListQuery holds query-string parameters for the list endpoint.+//+//nolint:lll+type KnowledgeListQuery struct {+ WithContent bool `form:"with_content" json:"with_content"`+ DocTypes []KnowledgeDocType `form:"doc_types[]" json:"doc_types,omitempty"`+ GuideTypes []KnowledgeGuideType `form:"guide_types[]" json:"guide_types,omitempty"`+ AnswerTypes []KnowledgeAnswerType `form:"answer_types[]" json:"answer_types,omitempty"`+ CodeLangs []string `form:"code_langs[]" json:"code_langs,omitempty"`+ FlowID *int64 `form:"flow_id" json:"flow_id,omitempty"`+ Manual *bool `form:"manual" json:"manual,omitempty"`+}++// Valid validates all enum values supplied in the list query.+func (q KnowledgeListQuery) Valid() error {+ for _, dt := range q.DocTypes {+ if err := dt.Valid(); err != nil {+ return err+ }+ }+ for _, gt := range q.GuideTypes {+ if err := gt.Valid(); err != nil {+ return err+ }+ }+ for _, at := range q.AnswerTypes {+ if err := at.Valid(); err != nil {+ return err+ }+ }+ return nil+}++// CreateKnowledgeDocRequest is the POST body for creating a knowledge document.+//+//nolint:lll+type CreateKnowledgeDocRequest struct {+ DocType KnowledgeDocType `json:"doc_type" validate:"required,valid"`+ Content string `json:"content" validate:"required,min=1,max=65536"`+ Question string `json:"question" validate:"required,min=1,max=2048"`+ Description *string `json:"description,omitempty" validate:"omitempty,max=1000"`+ GuideType *KnowledgeGuideType `json:"guide_type,omitempty" validate:"omitempty,valid"`+ AnswerType *KnowledgeAnswerType `json:"answer_type,omitempty" validate:"omitempty,valid"`+ CodeLang *string `json:"code_lang,omitempty" validate:"omitempty,max=100"`+}++// Valid implements IValid.+func (r CreateKnowledgeDocRequest) Valid() error {+ if err := r.DocType.Valid(); err != nil {+ return err+ }+ if r.GuideType != nil {+ if err := r.GuideType.Valid(); err != nil {+ return err+ }+ }+ if r.AnswerType != nil {+ if err := r.AnswerType.Valid(); err != nil {+ return err+ }+ }+ return validate.Struct(r)+}++// UpdateKnowledgeDocRequest is the PUT body for updating a knowledge document.+// content is mandatory (triggers re-embedding); all other fields are optional overrides.+//+//nolint:lll+type UpdateKnowledgeDocRequest struct {+ Content string `json:"content" validate:"required,min=1,max=65536"`+ Question *string `json:"question,omitempty" validate:"omitempty,min=1,max=2048"`+ Description *string `json:"description,omitempty" validate:"omitempty,max=1000"`+ GuideType *KnowledgeGuideType `json:"guide_type,omitempty" validate:"omitempty,valid"`+ AnswerType *KnowledgeAnswerType `json:"answer_type,omitempty" validate:"omitempty,valid"`+ CodeLang *string `json:"code_lang,omitempty" validate:"omitempty,max=100"`+}++// Valid implements IValid.+func (r UpdateKnowledgeDocRequest) Valid() error {+ if r.GuideType != nil {+ if err := r.GuideType.Valid(); err != nil {+ return err+ }+ }+ if r.AnswerType != nil {+ if err := r.AnswerType.Valid(); err != nil {+ return err+ }+ }+ return validate.Struct(r)+}++// KnowledgeSearchRequest is the POST body for semantic search.+//+//nolint:lll+type KnowledgeSearchRequest struct {+ Query string `json:"query" validate:"required,min=1,max=2048"`+ Limit int `json:"limit,omitempty" validate:"omitempty,min=1,max=100"`+ DocTypes []KnowledgeDocType `json:"doc_types,omitempty" validate:"omitempty,dive,valid"`+ GuideTypes []KnowledgeGuideType `json:"guide_types,omitempty" validate:"omitempty,dive,valid"`+ AnswerTypes []KnowledgeAnswerType `json:"answer_types,omitempty" validate:"omitempty,dive,valid"`+ CodeLangs []string `json:"code_langs,omitempty" validate:"omitempty,dive,max=100"`+ FlowID *int64 `json:"flow_id,omitempty"`+ Manual *bool `json:"manual,omitempty"`+}++// Valid implements IValid.+func (r KnowledgeSearchRequest) Valid() error {+ for _, dt := range r.DocTypes {+ if err := dt.Valid(); err != nil {+ return err+ }+ }+ for _, gt := range r.GuideTypes {+ if err := gt.Valid(); err != nil {+ return err+ }+ }+ for _, at := range r.AnswerTypes {+ if err := at.Valid(); err != nil {+ return err+ }+ }+ return validate.Struct(r)+}++// ==================== Converters (REST ↔ GraphQL model) ======================++// KnowledgeDocFromGQL converts a GraphQL KnowledgeDocument to a REST KnowledgeDocEntry.+func KnowledgeDocFromGQL(doc *gqlmodel.KnowledgeDocument) KnowledgeDocEntry {+ entry := KnowledgeDocEntry{+ ID: doc.ID,+ DocType: KnowledgeDocType(doc.DocType),+ Content: doc.Content,+ Question: doc.Question,+ UserID: doc.UserID,+ FlowID: doc.FlowID,+ TaskID: doc.TaskID,+ SubtaskID: doc.SubtaskID,+ PartSize: doc.PartSize,+ TotalSize: doc.TotalSize,+ Manual: doc.Manual,+ }+ if doc.Description != nil {+ entry.Description = doc.Description+ }+ if doc.GuideType != nil {+ gt := KnowledgeGuideType(*doc.GuideType)+ entry.GuideType = >+ }+ if doc.AnswerType != nil {+ at := KnowledgeAnswerType(*doc.AnswerType)+ entry.AnswerType = &at+ }+ if doc.CodeLang != nil {+ entry.CodeLang = doc.CodeLang+ }+ return entry+}++// KnowledgeDocListFromGQL converts a slice of GraphQL documents to a REST list response.+func KnowledgeDocListFromGQL(docs []*gqlmodel.KnowledgeDocument) KnowledgeDocList {+ items := make([]KnowledgeDocEntry, 0, len(docs))+ for _, d := range docs {+ items = append(items, KnowledgeDocFromGQL(d))+ }+ return KnowledgeDocList{Items: items, Total: uint64(len(items))}+}++// KnowledgeDocListFromRows converts raw gorm scan rows to a REST list response.+func KnowledgeDocListFromRows(rows []KnowledgeEmbeddingRow, total uint64, withContent bool) KnowledgeDocList {+ items := make([]KnowledgeDocEntry, 0, len(rows))+ for _, r := range rows {+ items = append(items, KnowledgeDocEntryFromRow(r, withContent))+ }+ return KnowledgeDocList{Items: items, Total: total}+}++// KnowledgeDocEntryFromRow converts a single gorm scan row to a REST KnowledgeDocEntry.+func KnowledgeDocEntryFromRow(r KnowledgeEmbeddingRow, withContent bool) KnowledgeDocEntry {+ meta := knowledgeMetaFromJSON(r.Cmetadata)+ content := r.Document+ if !withContent {+ content = ""+ }+ return knowledgeMetaToEntry(r.ID, content, meta)+}++// KnowledgeSearchResultFromGQL converts GraphQL search results to the REST response.+func KnowledgeSearchResultFromGQL(results []*gqlmodel.KnowledgeDocumentWithScore) KnowledgeSearchResult {+ items := make([]KnowledgeDocWithScore, 0, len(results))+ for _, r := range results {+ items = append(items, KnowledgeDocWithScore{+ Score: r.Score,+ Document: KnowledgeDocFromGQL(r.Document),+ })+ }+ return KnowledgeSearchResult{Items: items, Total: len(items)}+}++// CreateRequestToGQL converts a REST create request to the GraphQL input type.+func (r CreateKnowledgeDocRequest) ToGQL() gqlmodel.CreateKnowledgeDocumentInput {+ input := gqlmodel.CreateKnowledgeDocumentInput{+ DocType: gqlmodel.KnowledgeDocType(r.DocType),+ Content: r.Content,+ Question: r.Question,+ Description: r.Description,+ CodeLang: r.CodeLang,+ }+ if r.GuideType != nil {+ gt := gqlmodel.KnowledgeGuideType(*r.GuideType)+ input.GuideType = >+ }+ if r.AnswerType != nil {+ at := gqlmodel.KnowledgeAnswerType(*r.AnswerType)+ input.AnswerType = &at+ }+ return input+}++// UpdateRequestToGQL converts a REST update request to the GraphQL input type.+func (r UpdateKnowledgeDocRequest) ToGQL() gqlmodel.UpdateKnowledgeDocumentInput {+ input := gqlmodel.UpdateKnowledgeDocumentInput{+ Content: r.Content,+ Question: r.Question,+ Description: r.Description,+ CodeLang: r.CodeLang,+ }+ if r.GuideType != nil {+ gt := gqlmodel.KnowledgeGuideType(*r.GuideType)+ input.GuideType = >+ }+ if r.AnswerType != nil {+ at := gqlmodel.KnowledgeAnswerType(*r.AnswerType)+ input.AnswerType = &at+ }+ return input+}++// ListQueryToGQLFilter converts a REST list query to a GraphQL KnowledgeFilter.+func (q KnowledgeListQuery) ToGQLFilter() *gqlmodel.KnowledgeFilter {+ f := &gqlmodel.KnowledgeFilter{+ FlowID: q.FlowID,+ Manual: q.Manual,+ }+ for _, dt := range q.DocTypes {+ f.DocTypes = append(f.DocTypes, gqlmodel.KnowledgeDocType(dt))+ }+ for _, gt := range q.GuideTypes {+ f.GuideTypes = append(f.GuideTypes, gqlmodel.KnowledgeGuideType(gt))+ }+ for _, at := range q.AnswerTypes {+ f.AnswerTypes = append(f.AnswerTypes, gqlmodel.KnowledgeAnswerType(at))+ }+ f.CodeLangs = append(f.CodeLangs, q.CodeLangs...)+ if f.FlowID == nil && f.Manual == nil && len(f.DocTypes) == 0 &&+ len(f.GuideTypes) == 0 && len(f.AnswerTypes) == 0 && len(f.CodeLangs) == 0 {+ return nil+ }+ return f+}++// SearchRequestToGQLFilter converts a REST search request to a GraphQL KnowledgeFilter.+func (r KnowledgeSearchRequest) ToGQLFilter() *gqlmodel.KnowledgeFilter {+ f := &gqlmodel.KnowledgeFilter{+ FlowID: r.FlowID,+ Manual: r.Manual,+ }+ for _, dt := range r.DocTypes {+ f.DocTypes = append(f.DocTypes, gqlmodel.KnowledgeDocType(dt))+ }+ for _, gt := range r.GuideTypes {+ f.GuideTypes = append(f.GuideTypes, gqlmodel.KnowledgeGuideType(gt))+ }+ for _, at := range r.AnswerTypes {+ f.AnswerTypes = append(f.AnswerTypes, gqlmodel.KnowledgeAnswerType(at))+ }+ f.CodeLangs = append(f.CodeLangs, r.CodeLangs...)+ if f.FlowID == nil && f.Manual == nil && len(f.DocTypes) == 0 &&+ len(f.GuideTypes) == 0 && len(f.AnswerTypes) == 0 && len(f.CodeLangs) == 0 {+ return nil+ }+ return f+}diff --git a/backend/pkg/server/response/errors.go b/backend/pkg/server/response/errors.goindex e5aeff71..c8572982 100644--- a/backend/pkg/server/response/errors.go+++ b/backend/pkg/server/response/errors.go@@ -143,6 +143,14 @@ var ErrResourcesAlreadyExists = NewHttpError(409, "Resources.AlreadyExists", "rvar ErrResourcesInvalidData = NewHttpError(400, "Resources.InvalidData", "invalid resource data")var ErrResourcesConflict = NewHttpError(409, "Resources.Conflict", "resource conflict: use force=true to merge")+// knowledge++var ErrKnowledgeInvalidRequest = NewHttpError(400, "Knowledge.InvalidRequest", "invalid knowledge request data")+var ErrKnowledgeNotFound = NewHttpError(404, "Knowledge.NotFound", "knowledge document not found")+var ErrKnowledgeUnauthorized = NewHttpError(403, "Knowledge.Unauthorized", "not authorized to manage this knowledge document")+var ErrKnowledgeStoreUnavail = NewHttpError(503, "Knowledge.StoreUnavailable", "knowledge store (embedding provider) is not configured")+var ErrKnowledgeInvalidData = NewHttpError(500, "Knowledge.InvalidData", "invalid knowledge document data")+// tokensvar ErrTokenCreationDisabled = NewHttpError(400, "Token.CreationDisabled", "token creation is disabled with default configuration")diff --git a/backend/pkg/server/router.go b/backend/pkg/server/router.goindex 082d9d79..e84c4f51 100644--- a/backend/pkg/server/router.go+++ b/backend/pkg/server/router.go@@ -1,6 +1,7 @@package routerimport (+ "context""encoding/gob""net""net/http"@@ -16,6 +17,7 @@ import ("pentagi/pkg/config""pentagi/pkg/controller""pentagi/pkg/database"+ "pentagi/pkg/database/knowledge""pentagi/pkg/docker""pentagi/pkg/graph/subscriptions""pentagi/pkg/providers"@@ -35,6 +37,7 @@ import ("github.com/sirupsen/logrus"ginSwagger "github.com/swaggo/gin-swagger""github.com/swaggo/gin-swagger/swaggerFiles"+ "github.com/vxcontrol/langchaingo/vectorstores/pgvector")const baseURL = "/api/v1"@@ -118,6 +121,27 @@ func NewRouter(oauthClients[githubClient.ProviderName()] = githubClient}+ // ---- Knowledge (pgvector) store -----------------------------------------+ // Shared by both the GraphQL and REST layers.+ // Store and embedder are nil when no embedding provider is configured;+ // the knowledge store handles that gracefully (embedding-dependent ops error).+ embedder := providers.Embedder()+ var pgStore *pgvector.Store+ if embedder.IsAvailable() {+ if s, err := pgvector.New(+ context.Background(),+ pgvector.WithConnectionURL(cfg.DatabaseURL),+ pgvector.WithEmbedder(embedder),+ pgvector.WithCollectionName("langchain"),+ ); err == nil {+ pgStore = &s+ } else {+ logrus.WithError(err).Warn("failed to initialise pgvector store for knowledge API; embedding operations will be unavailable")+ }+ }+ var knowledgeStore knowledge.KnowledgeStore+ knowledgeStore = knowledge.NewKnowledgeStore(db, pgStore, embedder, subscriptions.NewKnowledgePublisher)+// servicesauthService := services.NewAuthService(services.AuthServiceConfig{@@ -148,8 +172,9 @@ func NewRouter(promptService := services.NewPromptService(orm)analyticsService := services.NewAnalyticsService(orm)tokenService := services.NewTokenService(orm, cfg.CookieSigningSalt, tokenCache, subscriptions)+ knowledgeService := services.NewKnowledgeService(orm, knowledgeStore)graphqlService := services.NewGraphqlService(- db, cfg, baseURL, cfg.CorsOrigins, tokenCache, providers, controller, subscriptions,+ db, cfg, baseURL, cfg.CorsOrigins, tokenCache, providers, controller, subscriptions, knowledgeStore,)router := gin.Default()@@ -225,6 +250,7 @@ func NewRouter({setGraphqlGroup(privateGroup, graphqlService)+ setKnowledgeGroup(privateGroup, knowledgeService)setProvidersGroup(privateGroup, providerService)setFlowsGroup(privateGroup, flowService)setFlowFilesGroup(privateGroup, flowFileService)@@ -313,6 +339,18 @@ func NewRouter(return router}+func setKnowledgeGroup(parent *gin.RouterGroup, svc *services.KnowledgeService) {+ kg := parent.Group("/knowledge")+ {+ kg.GET("/", svc.ListDocuments)+ kg.GET("/:id", svc.GetDocument)+ kg.POST("/", svc.CreateDocument)+ kg.POST("/search", svc.SearchDocuments)+ kg.PUT("/:id", svc.UpdateDocument)+ kg.DELETE("/:id", svc.DeleteDocument)+ }+}+func setProvidersGroup(parent *gin.RouterGroup, svc *services.ProviderService) {providersGroup := parent.Group("/providers"){diff --git a/backend/pkg/server/services/flow_files_test.go b/backend/pkg/server/services/flow_files_test.goindex 02d1c924..ff19eaa9 100644--- a/backend/pkg/server/services/flow_files_test.go+++ b/backend/pkg/server/services/flow_files_test.go@@ -842,6 +842,12 @@ func (s *flowFileCaptureSubscriptions) NewFlowTemplateSubscriber(int64) subscripfunc (s *flowFileCaptureSubscriptions) NewFlowTemplatePublisher(int64) subscriptions.FlowTemplatePublisher {return nil}+func (s *flowFileCaptureSubscriptions) NewKnowledgeSubscriber(int64) subscriptions.KnowledgeSubscriber {+ return nil+}+func (s *flowFileCaptureSubscriptions) NewKnowledgePublisher(int64) subscriptions.KnowledgePublisher {+ return nil+}func (s *flowFileCaptureSubscriptions) record(e flowFileEvent) {s.mu.Lock()@@ -901,6 +907,8 @@ func (p *captureFlowPublisher) VectorStoreLogAdded(_ context.Context, _ databasefunc (p *captureFlowPublisher) AssistantLogAdded(_ context.Context, _ database.Assistantlog) {}func (p *captureFlowPublisher) AssistantLogUpdated(_ context.Context, _ database.Assistantlog, _ bool) {}+func (p *captureFlowPublisher) KnowledgeDocumentCreated(_ context.Context, _ *graphmodel.KnowledgeDocument) {+}var _ subscriptions.FlowPublisher = (*captureFlowPublisher)(nil)var _ pconfig.ProviderConfig = pconfig.ProviderConfig{} // ensure pconfig import is referenceddiff --git a/backend/pkg/server/services/flows.go b/backend/pkg/server/services/flows.goindex 6675cedc..03fcb5ae 100644--- a/backend/pkg/server/services/flows.go+++ b/backend/pkg/server/services/flows.go@@ -602,6 +602,18 @@ func (s *FlowService) DeleteFlow(c *gin.Context) {return}+ // Best-effort cleanup: remove accumulated long-term memory documents for this+ // flow from the vector store. They will never be re-used after the flow is gone.+ if err := s.db.Exec(+ `DELETE FROM langchain_pg_embedding+ WHERE collection_id = (SELECT uuid FROM langchain_pg_collection WHERE name = 'langchain')+ AND COALESCE(cmetadata ->> 'doc_type', '') = 'memory'+ AND (cmetadata ->> 'flow_id') = ?`,+ strconv.FormatUint(flow.ID, 10),+ ).Error; err != nil {+ logger.FromContext(c).WithError(err).Warnf("failed to clean up memory documents for deleted flow %d", flow.ID)+ }+flowDB, err := convertFlowToDatabase(flow)if err != nil {logger.FromContext(c).WithError(err).Errorf("error converting flow to database")diff --git a/backend/pkg/server/services/graphql.go b/backend/pkg/server/services/graphql.goindex fb6882b4..99029b72 100644--- a/backend/pkg/server/services/graphql.go+++ b/backend/pkg/server/services/graphql.go@@ -11,6 +11,7 @@ import ("pentagi/pkg/config""pentagi/pkg/controller""pentagi/pkg/database"+ "pentagi/pkg/database/knowledge""pentagi/pkg/graph""pentagi/pkg/graph/subscriptions""pentagi/pkg/providers"@@ -56,6 +57,7 @@ func NewGraphqlService(providers providers.ProviderController,controller controller.FlowController,subscriptions subscriptions.SubscriptionsController,+ knowledgeStore knowledge.KnowledgeStore,) *GraphqlService {srv := handler.New(graph.NewExecutableSchema(graph.Config{Resolvers: &graph.Resolver{DB: db,@@ -66,6 +68,7 @@ func NewGraphqlService(ProvidersCtrl: providers,Controller: controller,Subscriptions: subscriptions,+ Knowledge: knowledgeStore,}}))component := "pentagi-gql"diff --git a/backend/pkg/server/services/knowledge.go b/backend/pkg/server/services/knowledge.gonew file mode 100644index 00000000..8804a01f--- /dev/null+++ b/backend/pkg/server/services/knowledge.go@@ -0,0 +1,519 @@+package services++import (+ "errors"+ "net/http"+ "strings"++ knowledgepkg "pentagi/pkg/database/knowledge"+ gqlmodel "pentagi/pkg/graph/model"+ "pentagi/pkg/server/auth"+ "pentagi/pkg/server/logger"+ "pentagi/pkg/server/models"+ "pentagi/pkg/server/rdb"+ "pentagi/pkg/server/response"++ "github.com/gin-gonic/gin"+ "github.com/jinzhu/gorm"+)++// knowledgeSQLMappers maps rdb filter field names to the corresponding SQL+// expressions against langchain_pg_embedding / its cmetadata JSON column.+// Fields ending in _id are treated as numeric by rdb (operator = instead of like),+// so numeric JSON fields use custom function mappers that cast cmetadata values.+var knowledgeSQLMappers = map[string]any{+ // Primary key exposed as "id" so TableQuery default ordering still works via SetOrders override.+ "id": "langchain_pg_embedding.uuid::text",++ // Text fields from cmetadata — rdb wraps them in LOWER(…::text) automatically.+ "doc_type": "(langchain_pg_embedding.cmetadata ->> 'doc_type')",+ "question": "(langchain_pg_embedding.cmetadata ->> 'question')",+ "description": "(langchain_pg_embedding.cmetadata ->> 'description')",+ "guide_type": "(langchain_pg_embedding.cmetadata ->> 'guide_type')",+ "answer_type": "(langchain_pg_embedding.cmetadata ->> 'answer_type')",+ "code_lang": "(langchain_pg_embedding.cmetadata ->> 'code_lang')",++ // Searchable concat of common text fields for generic "data" filter.+ "data": "((langchain_pg_embedding.cmetadata ->> 'doc_type') || ' ' || " ++ "COALESCE(langchain_pg_embedding.cmetadata ->> 'question', ''))",++ // Numeric ID fields: stored as JSON numbers; cast to bigint before comparison.+ "user_id": func(q *rdb.TableQuery, db *gorm.DB, value any) *gorm.DB {+ return applyKnowledgeIntFilter(db, "user_id", value)+ },+ "flow_id": func(q *rdb.TableQuery, db *gorm.DB, value any) *gorm.DB {+ return applyKnowledgeIntFilter(db, "flow_id", value)+ },+ "task_id": func(q *rdb.TableQuery, db *gorm.DB, value any) *gorm.DB {+ return applyKnowledgeIntFilter(db, "task_id", value)+ },+ "subtask_id": func(q *rdb.TableQuery, db *gorm.DB, value any) *gorm.DB {+ return applyKnowledgeIntFilter(db, "subtask_id", value)+ },++ // Boolean field: 'true' / anything else (JSON booleans serialise as 'true'/'false').+ "manual": func(q *rdb.TableQuery, db *gorm.DB, value any) *gorm.DB {+ if b, ok := value.(bool); ok {+ if b {+ return db.Where("(langchain_pg_embedding.cmetadata ->> 'manual') = 'true'")+ }+ return db.Where("(langchain_pg_embedding.cmetadata ->> 'manual') IS DISTINCT FROM 'true'")+ }+ return db+ },+}++// applyKnowledgeIntFilter adds a bigint equality / IN filter against a cmetadata integer field.+func applyKnowledgeIntFilter(db *gorm.DB, field string, value any) *gorm.DB {+ expr := "(langchain_pg_embedding.cmetadata ->> '" + field + "')::bigint"+ switch v := value.(type) {+ case float64:+ return db.Where(expr+" = ?", int64(v))+ case []any:+ var ids []int64+ for _, vi := range v {+ if f, ok := vi.(float64); ok {+ ids = append(ids, int64(f))+ }+ }+ if len(ids) > 0 {+ return db.Where(expr+" IN (?)", ids)+ }+ }+ return db+}++// knowledgeGrouped is the response shape for grouped list queries.+type knowledgeGrouped struct {+ Grouped []string `json:"grouped"`+ Total uint64 `json:"total"`+}++// KnowledgeService exposes the knowledge (pgvector) store via a REST API+// that mirrors the GraphQL knowledge operations.+//+// Authorization model:+// - knowledge.admin → read/write any document (no user_id filtering)+// - knowledge.view → list/get own documents (filtered by user_id)+// - knowledge.create → create a new document+// - knowledge.edit → update own document (admin: any)+// - knowledge.delete → delete own document (admin: any)+// - knowledge.search → semantic search (own docs for regular users)+type KnowledgeService struct {+ db *gorm.DB+ store knowledgepkg.KnowledgeStore+}++// NewKnowledgeService creates a KnowledgeService.+// db is the gorm connection used for paginated list queries via rdb.TableQuery.+// store may be nil when the embedding provider is not configured; in that+// case embedding-dependent endpoints return 503.+func NewKnowledgeService(db *gorm.DB, store knowledgepkg.KnowledgeStore) *KnowledgeService {+ return &KnowledgeService{db: db, store: store}+}++func isKnowledgeAdmin(c *gin.Context) bool {+ return auth.LookupPerm(c.GetStringSlice("prm"), "knowledge.admin")+}++// ---- ListDocuments ----------------------------------------------------------++// ListDocuments returns a paginated, sortable, filterable list of knowledge documents.+// It uses the standard rdb.TableQuery protocol (page, pageSize, sort[], filters[])+// plus an additional `with_content` boolean query parameter.+//+// Filterable fields:+// - id – UUID (exact match)+// - doc_type – answer | guide | code (text, like/=)+// - question – question text (text, like)+// - description – description text (text, like)+// - guide_type – guide sub-type (text, like/=)+// - answer_type – answer sub-type (text, like/=)+// - code_lang – code language (text, like/=)+// - manual – boolean flag (bool, =)+// - user_id – owner user ID (int64, =/in)+// - flow_id – originating flow ID (int64, =/in)+// - task_id – originating task ID (int64, =/in)+// - subtask_id – originating subtask ID (int64, =/in)+// - data – full-text across doc_type + question (text, like)+//+// @Summary List knowledge documents+// @Tags Knowledge+// @Produce json+// @Security BearerAuth+// @Param request query rdb.TableQuery true "pagination / sort / filter params"+// @Param with_content query bool false "include document text in the response"+// @Success 200 {object} response.successResp{data=models.KnowledgeDocList}+// @Failure 400 {object} response.errorResp "invalid query parameters"+// @Failure 403 {object} response.errorResp "not permitted"+// @Failure 500 {object} response.errorResp "internal error"+// @Router /knowledge/ [get]+func (s *KnowledgeService) ListDocuments(c *gin.Context) {+ uid := int64(c.GetUint64("uid"))+ admin := isKnowledgeAdmin(c)++ var query rdb.TableQuery+ if err := c.ShouldBindQuery(&query); err != nil {+ logger.FromContext(c).WithError(err).Error("error binding list query")+ response.Error(c, response.ErrKnowledgeInvalidRequest, err)+ return+ }++ withContent := c.Query("with_content") == "true" || c.Query("with_content") == "1"++ if err := query.Init("langchain_pg_embedding", knowledgeSQLMappers); err != nil {+ // Init fails when the requested group field is not a sortable string column+ // (e.g. a custom function mapper like user_id).+ logger.FromContext(c).WithError(err).Error("error initialising knowledge query")+ response.Error(c, response.ErrKnowledgeInvalidRequest, err)+ return+ }++ // Base scope: JOIN the collection table, restrict to 'langchain', exclude memory.+ baseScope := func(db *gorm.DB) *gorm.DB {+ return db.+ Joins("JOIN langchain_pg_collection ON langchain_pg_embedding.collection_id = langchain_pg_collection.uuid").+ Where("langchain_pg_collection.name = ?", "langchain").+ Where("COALESCE(langchain_pg_embedding.cmetadata ->> 'doc_type', '') NOT IN (?)", []string{"memory"})+ }++ // Authorization scope: admins see all documents; regular users see only their own.+ authScope := func(db *gorm.DB) *gorm.DB {+ if admin {+ return db+ }+ return db.Where("(langchain_pg_embedding.cmetadata ->> 'user_id')::bigint = ?", uid)+ }++ // ---- Grouped query -------------------------------------------------------+ // When a group field is requested the response is a list of distinct values+ // rather than full document rows (mirrors the pattern used in other services).+ if query.Group != "" {+ if _, ok := knowledgeSQLMappers[query.Group]; !ok {+ logger.FromContext(c).Errorf("group field %q not found in knowledge mappers", query.Group)+ response.Error(c, response.ErrKnowledgeInvalidRequest, errors.New("group field not found"))+ return+ }++ var resp knowledgeGrouped+ var err error+ if resp.Total, err = query.QueryGrouped(s.db, &resp.Grouped, baseScope, authScope); err != nil {+ logger.FromContext(c).WithError(err).Error("error querying knowledge documents grouped")+ response.Error(c, response.ErrInternal, err)+ return+ }++ response.Success(c, http.StatusOK, resp)+ return+ }++ // ---- Paginated / sorted query --------------------------------------------++ // Override the default "ORDER BY id DESC" — the PK column is uuid, not id.+ query.SetOrders([]func(*gorm.DB) *gorm.DB{+ func(db *gorm.DB) *gorm.DB {+ return db.Order("langchain_pg_embedding.uuid DESC")+ },+ })++ // SELECT only the columns the API exposes; never return the embedding vector.+ query.SetFind(func(out any) func(*gorm.DB) *gorm.DB {+ docCol := "'' AS document"+ if withContent {+ docCol = "COALESCE(langchain_pg_embedding.document, '') AS document"+ }+ sel := "langchain_pg_embedding.uuid::text AS id, " ++ docCol + ", " ++ "COALESCE(langchain_pg_embedding.cmetadata::text, '{}') AS cmetadata"+ return func(db *gorm.DB) *gorm.DB {+ return db.Select(sel).Find(out)+ }+ })++ var rows []models.KnowledgeEmbeddingRow+ total, err := query.Query(s.db, &rows, baseScope, authScope)+ if err != nil {+ logger.FromContext(c).WithError(err).Error("error querying knowledge documents")+ response.Error(c, response.ErrInternal, err)+ return+ }++ response.Success(c, http.StatusOK, models.KnowledgeDocListFromRows(rows, total, withContent))+}++// ---- GetDocument ------------------------------------------------------------++// GetDocument returns a single knowledge document by its UUID.+//+// @Summary Get knowledge document+// @Tags Knowledge+// @Produce json+// @Security BearerAuth+// @Param id path string true "Document UUID"+// @Success 200 {object} response.successResp{data=models.KnowledgeDocEntry}+// @Failure 403 {object} response.errorResp "not permitted or wrong owner"+// @Failure 404 {object} response.errorResp "document not found"+// @Failure 500 {object} response.errorResp "internal error"+// @Router /knowledge/{id} [get]+func (s *KnowledgeService) GetDocument(c *gin.Context) {+ uid := int64(c.GetUint64("uid"))+ admin := isKnowledgeAdmin(c)+ id := c.Param("id")++ if id == "" {+ response.Error(c, response.ErrKnowledgeInvalidRequest, errors.New("document id is required"))+ return+ }++ ctx := c.Request.Context()++ var (+ doc *gqlmodel.KnowledgeDocument+ err error+ )+ if admin {+ doc, err = s.store.GetDocument(ctx, id)+ } else {+ doc, err = s.store.GetUserDocument(ctx, uid, id)+ }+ if err != nil {+ logger.FromContext(c).WithError(err).Errorf("error getting knowledge document %s", id)+ response.Error(c, response.ErrKnowledgeNotFound, err)+ return+ }++ response.Success(c, http.StatusOK, models.KnowledgeDocFromGQL(doc))+}++// ---- SearchDocuments --------------------------------------------------------++// SearchDocuments performs a semantic similarity search over the knowledge store.+//+// @Summary Semantic search in knowledge base+// @Tags Knowledge+// @Accept json+// @Produce json+// @Security BearerAuth+// @Param json body models.KnowledgeSearchRequest true "Search request"+// @Success 200 {object} response.successResp{data=models.KnowledgeSearchResult}+// @Failure 400 {object} response.errorResp "invalid request"+// @Failure 403 {object} response.errorResp "not permitted"+// @Failure 503 {object} response.errorResp "embedding provider not configured"+// @Failure 500 {object} response.errorResp "internal error"+// @Router /knowledge/search [post]+func (s *KnowledgeService) SearchDocuments(c *gin.Context) {+ uid := int64(c.GetUint64("uid"))+ admin := isKnowledgeAdmin(c)++ var req models.KnowledgeSearchRequest+ if err := c.ShouldBindJSON(&req); err != nil {+ logger.FromContext(c).WithError(err).Error("error binding search request")+ response.Error(c, response.ErrKnowledgeInvalidRequest, err)+ return+ }+ if err := req.Valid(); err != nil {+ logger.FromContext(c).WithError(err).Error("invalid search request")+ response.Error(c, response.ErrKnowledgeInvalidRequest, err)+ return+ }++ ctx := c.Request.Context()+ filter := req.ToGQLFilter()++ var (+ results []*gqlmodel.KnowledgeDocumentWithScore+ err error+ )+ if admin {+ results, err = s.store.SearchDocuments(ctx, req.Query, filter, req.Limit)+ } else {+ results, err = s.store.SearchUserDocuments(ctx, uid, req.Query, filter, req.Limit)+ }+ if err != nil {+ if isKnowledgeStoreUnavailable(err) {+ response.Error(c, response.ErrKnowledgeStoreUnavail, err)+ return+ }+ logger.FromContext(c).WithError(err).Error("error searching knowledge documents")+ response.Error(c, response.ErrInternal, err)+ return+ }++ response.Success(c, http.StatusOK, models.KnowledgeSearchResultFromGQL(results))+}++// ---- CreateDocument ---------------------------------------------------------++// CreateDocument creates a new knowledge document and computes its embedding.+//+// @Summary Create knowledge document+// @Tags Knowledge+// @Accept json+// @Produce json+// @Security BearerAuth+// @Param json body models.CreateKnowledgeDocRequest true "Create request"+// @Success 201 {object} response.successResp{data=models.KnowledgeDocEntry}+// @Failure 400 {object} response.errorResp "invalid request"+// @Failure 403 {object} response.errorResp "not permitted"+// @Failure 503 {object} response.errorResp "embedding provider not configured"+// @Failure 500 {object} response.errorResp "internal error"+// @Router /knowledge/ [post]+func (s *KnowledgeService) CreateDocument(c *gin.Context) {+ uid := int64(c.GetUint64("uid"))++ var req models.CreateKnowledgeDocRequest+ if err := c.ShouldBindJSON(&req); err != nil {+ logger.FromContext(c).WithError(err).Error("error binding create request")+ response.Error(c, response.ErrKnowledgeInvalidRequest, err)+ return+ }+ if err := req.Valid(); err != nil {+ logger.FromContext(c).WithError(err).Error("invalid create request")+ response.Error(c, response.ErrKnowledgeInvalidRequest, err)+ return+ }++ doc, err := s.store.CreateDocument(c.Request.Context(), uid, req.ToGQL())+ if err != nil {+ if isKnowledgeStoreUnavailable(err) {+ response.Error(c, response.ErrKnowledgeStoreUnavail, err)+ return+ }+ logger.FromContext(c).WithError(err).Error("error creating knowledge document")+ response.Error(c, response.ErrInternal, err)+ return+ }++ response.Success(c, http.StatusCreated, models.KnowledgeDocFromGQL(doc))+}++// ---- UpdateDocument ---------------------------------------------------------++// UpdateDocument updates a knowledge document, re-computing its embedding.+// Admin can update any document; regular users can only update their own.+//+// @Summary Update knowledge document+// @Tags Knowledge+// @Accept json+// @Produce json+// @Security BearerAuth+// @Param id path string true "Document UUID"+// @Param json body models.UpdateKnowledgeDocRequest true "Update request"+// @Success 200 {object} response.successResp{data=models.KnowledgeDocEntry}+// @Failure 400 {object} response.errorResp "invalid request"+// @Failure 403 {object} response.errorResp "not permitted or wrong owner"+// @Failure 404 {object} response.errorResp "document not found"+// @Failure 503 {object} response.errorResp "embedding provider not configured"+// @Failure 500 {object} response.errorResp "internal error"+// @Router /knowledge/{id} [put]+func (s *KnowledgeService) UpdateDocument(c *gin.Context) {+ uid := int64(c.GetUint64("uid"))+ admin := isKnowledgeAdmin(c)+ id := c.Param("id")++ if id == "" {+ response.Error(c, response.ErrKnowledgeInvalidRequest, errors.New("document id is required"))+ return+ }++ var req models.UpdateKnowledgeDocRequest+ if err := c.ShouldBindJSON(&req); err != nil {+ logger.FromContext(c).WithError(err).Error("error binding update request")+ response.Error(c, response.ErrKnowledgeInvalidRequest, err)+ return+ }+ if err := req.Valid(); err != nil {+ logger.FromContext(c).WithError(err).Error("invalid update request")+ response.Error(c, response.ErrKnowledgeInvalidRequest, err)+ return+ }++ ctx := c.Request.Context()+ input := req.ToGQL()++ var (+ doc *gqlmodel.KnowledgeDocument+ err error+ )+ if admin {+ doc, err = s.store.UpdateDocument(ctx, uid, id, input)+ } else {+ doc, err = s.store.UpdateUserDocument(ctx, uid, id, input)+ }+ if err != nil {+ if isKnowledgeStoreUnavailable(err) {+ response.Error(c, response.ErrKnowledgeStoreUnavail, err)+ return+ }+ if isKnowledgeNotFound(err) {+ response.Error(c, response.ErrKnowledgeNotFound, err)+ return+ }+ logger.FromContext(c).WithError(err).Errorf("error updating knowledge document %s", id)+ response.Error(c, response.ErrInternal, err)+ return+ }++ response.Success(c, http.StatusOK, models.KnowledgeDocFromGQL(doc))+}++// ---- DeleteDocument ---------------------------------------------------------++// DeleteDocument deletes a knowledge document by UUID.+// Admin can delete any document; regular users can only delete their own.+//+// @Summary Delete knowledge document+// @Tags Knowledge+// @Produce json+// @Security BearerAuth+// @Param id path string true "Document UUID"+// @Success 200 {object} response.successResp "document deleted"+// @Failure 403 {object} response.errorResp "not permitted or wrong owner"+// @Failure 404 {object} response.errorResp "document not found"+// @Failure 500 {object} response.errorResp "internal error"+// @Router /knowledge/{id} [delete]+func (s *KnowledgeService) DeleteDocument(c *gin.Context) {+ uid := int64(c.GetUint64("uid"))+ admin := isKnowledgeAdmin(c)+ id := c.Param("id")++ if id == "" {+ response.Error(c, response.ErrKnowledgeInvalidRequest, errors.New("document id is required"))+ return+ }++ ctx := c.Request.Context()++ var err error+ if admin {+ err = s.store.DeleteDocument(ctx, uid, id)+ } else {+ err = s.store.DeleteUserDocument(ctx, uid, id)+ }+ if err != nil {+ if isKnowledgeNotFound(err) {+ response.Error(c, response.ErrKnowledgeNotFound, err)+ return+ }+ logger.FromContext(c).WithError(err).Errorf("error deleting knowledge document %s", id)+ response.Error(c, response.ErrInternal, err)+ return+ }++ response.Success(c, http.StatusOK, gin.H{"message": "knowledge document deleted successfully"})+}++// ---- error classification ---------------------------------------------------++// isKnowledgeStoreUnavailable returns true when the error originates from a+// missing embedding provider (store or embedder not configured).+func isKnowledgeStoreUnavailable(err error) bool {+ return err != nil && strings.Contains(err.Error(), "knowledge: embedding provider")+}++// isKnowledgeNotFound returns true when the underlying DB returned no rows,+// which means the document does not exist or does not belong to the caller.+func isKnowledgeNotFound(err error) bool {+ return err != nil && (strings.Contains(err.Error(), "no rows") ||+ strings.Contains(err.Error(), "not found"))+}diff --git a/backend/pkg/server/services/resources_test.go b/backend/pkg/server/services/resources_test.goindex eee81b63..0a009d0a 100644--- a/backend/pkg/server/services/resources_test.go+++ b/backend/pkg/server/services/resources_test.go@@ -208,6 +208,12 @@ func (s *captureSubscriptions) NewFlowTemplatePublisher(int64) subscriptions.Flofunc (s *captureSubscriptions) NewResourcePublisher(int64) subscriptions.ResourcePublisher {return &captureResourcePublisher{events: &s.events}}+func (s *captureSubscriptions) NewKnowledgeSubscriber(int64) subscriptions.KnowledgeSubscriber {+ return nil+}+func (s *captureSubscriptions) NewKnowledgePublisher(int64) subscriptions.KnowledgePublisher {+ return nil+}type captureResourcePublisher struct {userID int64@@ -499,9 +505,9 @@ func TestResourceService_ListResourcesScenarios(t *testing.T) {{userID: 1, path: "shared/sub", isDir: true},{userID: 1, path: "shared/sub/file.txt", content: "x"},},- paths: []string{"shared/sub"},- privs: []string{"resources.view"},- wantStatus: http.StatusOK,+ paths: []string{"shared/sub"},+ privs: []string{"resources.view"},+ wantStatus: http.StatusOK,// "shared" belongs to user 2 → not returned for user 1wantResponsePaths: []string{"shared/sub", "shared/sub/file.txt"},},@@ -1242,8 +1248,8 @@ func TestResourceService_DownloadResourceScenarios(t *testing.T) {wantContentType: "application/zip",wantDispContains: "download.zip",wantZipEntries: map[string]string{- "report.txt": "report-data",- "docs/a.txt": "a-data",+ "report.txt": "report-data",+ "docs/a.txt": "a-data","docs/sub/b.txt": "b-data",},},diff --git a/backend/pkg/tools/code.go b/backend/pkg/tools/code.goindex 027dacf7..c8eb06ee 100644--- a/backend/pkg/tools/code.go+++ b/backend/pkg/tools/code.go@@ -7,6 +7,7 @@ import ("strings""pentagi/pkg/database"+ "pentagi/pkg/graph/model"obs "pentagi/pkg/observability""pentagi/pkg/observability/langfuse"@@ -26,28 +27,34 @@ const ()type code struct {+ userID int64flowID int64taskID *int64subtaskID *int64replacer anonymizer.Replacerstore *pgvector.Storevslp VectorStoreLogProvider+ knp KnowledgeProvider}func NewCodeTool(+ userID int64,flowID int64,taskID, subtaskID *int64,replacer anonymizer.Replacer,store *pgvector.Store,vslp VectorStoreLogProvider,+ knp KnowledgeProvider,) Tool {return &code{+ userID: userID,flowID: flowID,taskID: taskID,subtaskID: subtaskID,replacer: replacer,store: store,vslp: vslp,+ knp: knp,}}@@ -251,6 +258,7 @@ func (c *code) Handle(ctx context.Context, name string, args json.RawMessage) (sif doc.Metadata == nil {doc.Metadata = map[string]any{}}+ doc.Metadata["user_id"] = c.userIDdoc.Metadata["flow_id"] = c.flowIDif c.taskID != nil {doc.Metadata["task_id"] = *c.taskID@@ -266,7 +274,8 @@ func (c *code) Handle(ctx context.Context, name string, args json.RawMessage) (sdoc.Metadata["total_size"] = len(anonymizedCode)}- if _, err := c.store.AddDocuments(ctx, docs); err != nil {+ ids, err := c.store.AddDocuments(ctx, docs)+ if err != nil {observation.Event(append(opts,langfuse.WithEventStatus(err.Error()),langfuse.WithEventLevel(langfuse.ObservationLevelError),@@ -281,6 +290,34 @@ func (c *code) Handle(ctx context.Context, name string, args json.RawMessage) (slangfuse.WithEventOutput(docs),)...)+ if c.knp != nil {+ codeLang := action.Lang+ for i, doc := range docs {+ if i >= len(ids) {+ break+ }+ desc := action.Description+ knDoc := &model.KnowledgeDocument{+ ID: ids[i],+ UserID: c.userID,+ DocType: model.KnowledgeDocTypeCode,+ Content: doc.PageContent,+ Question: anonymizedQuestion,+ Description: &desc,+ CodeLang: &codeLang,+ PartSize: len(doc.PageContent),+ TotalSize: len(anonymizedCode),+ Manual: false,+ }+ if c.flowID != 0 {+ knDoc.FlowID = &c.flowID+ }+ knDoc.TaskID = c.taskID+ knDoc.SubtaskID = c.subtaskID+ c.knp.KnowledgeDocumentCreated(ctx, knDoc)+ }+ }+if agentCtx, ok := GetAgentContext(ctx); ok {data := map[string]any{"doc_type": codeVectorStoreDefaultType,diff --git a/backend/pkg/tools/executor.go b/backend/pkg/tools/executor.goindex c885b401..c6322ebc 100644--- a/backend/pkg/tools/executor.go+++ b/backend/pkg/tools/executor.go@@ -130,6 +130,7 @@ func (w *noopObservationWrapper) end(result string, err error, durationSeconds f}type customExecutor struct {+ userID int64flowID int64taskID *int64subtaskID *int64@@ -563,13 +564,14 @@ func (ce *customExecutor) storeToolResult(ctx context.Context, name, result striif doc.Metadata == nil {doc.Metadata = map[string]any{}}+ doc.Metadata["user_id"] = ce.userID+ doc.Metadata["flow_id"] = ce.flowIDif ce.taskID != nil {doc.Metadata["task_id"] = *ce.taskID}if ce.subtaskID != nil {doc.Metadata["subtask_id"] = *ce.subtaskID}- doc.Metadata["flow_id"] = ce.flowIDdoc.Metadata["tool_name"] = nameif def, ok := registryDefinitions[name]; ok {doc.Metadata["tool_description"] = def.Descriptiondiff --git a/backend/pkg/tools/guide.go b/backend/pkg/tools/guide.goindex bc23ea57..07e77030 100644--- a/backend/pkg/tools/guide.go+++ b/backend/pkg/tools/guide.go@@ -7,6 +7,7 @@ import ("strings""pentagi/pkg/database"+ "pentagi/pkg/graph/model"obs "pentagi/pkg/observability""pentagi/pkg/observability/langfuse"@@ -26,27 +27,32 @@ const ()type guide struct {+ userID int64flowID int64taskID *int64subtaskID *int64replacer anonymizer.Replacerstore *pgvector.Storevslp VectorStoreLogProvider+ knp KnowledgeProvider}func NewGuideTool(- flowID int64, taskID, subtaskID *int64,+ userID int64, flowID int64, taskID, subtaskID *int64,replacer anonymizer.Replacer,store *pgvector.Store,vslp VectorStoreLogProvider,+ knp KnowledgeProvider,) Tool {return &guide{+ userID: userID,flowID: flowID,taskID: taskID,subtaskID: subtaskID,replacer: replacer,store: store,vslp: vslp,+ knp: knp,}}@@ -245,6 +251,7 @@ func (g *guide) Handle(ctx context.Context, name string, args json.RawMessage) (if doc.Metadata == nil {doc.Metadata = map[string]any{}}+ doc.Metadata["user_id"] = g.userIDdoc.Metadata["flow_id"] = g.flowIDif g.taskID != nil {doc.Metadata["task_id"] = *g.taskID@@ -259,7 +266,8 @@ func (g *guide) Handle(ctx context.Context, name string, args json.RawMessage) (doc.Metadata["total_size"] = len(anonymizedGuide)}- if _, err := g.store.AddDocuments(ctx, docs); err != nil {+ ids, err := g.store.AddDocuments(ctx, docs)+ if err != nil {observation.Event(append(opts,langfuse.WithEventStatus(err.Error()),langfuse.WithEventLevel(langfuse.ObservationLevelError),@@ -274,6 +282,32 @@ func (g *guide) Handle(ctx context.Context, name string, args json.RawMessage) (langfuse.WithEventOutput(docs),)...)+ if g.knp != nil {+ guideType := model.KnowledgeGuideType(action.Type)+ for i, doc := range docs {+ if i >= len(ids) {+ break+ }+ knDoc := &model.KnowledgeDocument{+ ID: ids[i],+ UserID: g.userID,+ DocType: model.KnowledgeDocTypeGuide,+ Content: doc.PageContent,+ Question: anonymizedQuestion,+ GuideType: &guideType,+ PartSize: len(doc.PageContent),+ TotalSize: len(anonymizedGuide),+ Manual: false,+ }+ if g.flowID != 0 {+ knDoc.FlowID = &g.flowID+ }+ knDoc.TaskID = g.taskID+ knDoc.SubtaskID = g.subtaskID+ g.knp.KnowledgeDocumentCreated(ctx, knDoc)+ }+ }+if agentCtx, ok := GetAgentContext(ctx); ok {data := map[string]any{"doc_type": guideVectorStoreDefaultType,diff --git a/backend/pkg/tools/search.go b/backend/pkg/tools/search.goindex 63f65714..e1c9deca 100644--- a/backend/pkg/tools/search.go+++ b/backend/pkg/tools/search.go@@ -7,6 +7,7 @@ import ("strings""pentagi/pkg/database"+ "pentagi/pkg/graph/model"obs "pentagi/pkg/observability""pentagi/pkg/observability/langfuse"@@ -26,28 +27,34 @@ const ()type search struct {+ userID int64flowID int64taskID *int64subtaskID *int64replacer anonymizer.Replacerstore *pgvector.Storevslp VectorStoreLogProvider+ knp KnowledgeProvider}func NewSearchTool(+ userID int64,flowID int64,taskID, subtaskID *int64,replacer anonymizer.Replacer,store *pgvector.Store,vslp VectorStoreLogProvider,+ knp KnowledgeProvider,) Tool {return &search{+ userID: userID,flowID: flowID,taskID: taskID,subtaskID: subtaskID,replacer: replacer,store: store,vslp: vslp,+ knp: knp,}}@@ -240,6 +247,7 @@ func (s *search) Handle(ctx context.Context, name string, args json.RawMessage)if doc.Metadata == nil {doc.Metadata = map[string]any{}}+ doc.Metadata["user_id"] = s.userIDdoc.Metadata["flow_id"] = s.flowIDdoc.Metadata["task_id"] = s.taskIDdoc.Metadata["subtask_id"] = s.subtaskID@@ -250,7 +258,8 @@ func (s *search) Handle(ctx context.Context, name string, args json.RawMessage)doc.Metadata["total_size"] = len(anonymizedAnswer)}- if _, err := s.store.AddDocuments(ctx, docs); err != nil {+ ids, err := s.store.AddDocuments(ctx, docs)+ if err != nil {observation.Event(append(opts,langfuse.WithEventStatus(err.Error()),langfuse.WithEventLevel(langfuse.ObservationLevelError),@@ -265,6 +274,32 @@ func (s *search) Handle(ctx context.Context, name string, args json.RawMessage)langfuse.WithEventOutput(docs),)...)+ if s.knp != nil {+ answerType := model.KnowledgeAnswerType(action.Type)+ for i, doc := range docs {+ if i >= len(ids) {+ break+ }+ knDoc := &model.KnowledgeDocument{+ ID: ids[i],+ UserID: s.userID,+ DocType: model.KnowledgeDocTypeAnswer,+ Content: doc.PageContent,+ Question: anonymizedQuestion,+ AnswerType: &answerType,+ PartSize: len(doc.PageContent),+ TotalSize: len(anonymizedAnswer),+ Manual: false,+ }+ if s.flowID != 0 {+ knDoc.FlowID = &s.flowID+ }+ knDoc.TaskID = s.taskID+ knDoc.SubtaskID = s.subtaskID+ s.knp.KnowledgeDocumentCreated(ctx, knDoc)+ }+ }+if agentCtx, ok := GetAgentContext(ctx); ok {filtersData, err := json.Marshal(map[string]any{"doc_type": searchVectorStoreDefaultType,diff --git a/backend/pkg/tools/tools.go b/backend/pkg/tools/tools.goindex b8cf6ec2..9c677e18 100644--- a/backend/pkg/tools/tools.go+++ b/backend/pkg/tools/tools.go@@ -17,6 +17,7 @@ import ("pentagi/pkg/database""pentagi/pkg/docker""pentagi/pkg/flowfiles"+ "pentagi/pkg/graph/model""pentagi/pkg/graphiti""pentagi/pkg/providers/embeddings""pentagi/pkg/schema"@@ -140,7 +141,12 @@ type VectorStoreLogProvider interface {) (int64, error)}+type KnowledgeProvider interface {+ KnowledgeDocumentCreated(ctx context.Context, doc *model.KnowledgeDocument)+}+type flowToolsExecutor struct {+ userID int64flowID int64scp ScreenshotProvideralp AgentLogProvider@@ -148,6 +154,7 @@ type flowToolsExecutor struct {slp SearchLogProvidertlp TermLogProvidervslp VectorStoreLogProvider+ knp KnowledgeProviderdb database.Queriercfg *config.Config@@ -293,6 +300,7 @@ type ReporterExecutorConfig struct {}type FlowToolsExecutor interface {+ SetUserID(userID int64)SetFlowID(flowID int64)SetImage(image string)SetEmbedder(embedder embeddings.Embedder)@@ -303,6 +311,7 @@ type FlowToolsExecutor interface {SetSearchLogProvider(slp SearchLogProvider)SetTermLogProvider(tlp TermLogProvider)SetVectorStoreLogProvider(vslp VectorStoreLogProvider)+ SetKnowledgeProvider(knp KnowledgeProvider)SetGraphitiClient(client *graphiti.Client)Prepare(ctx context.Context) error@@ -326,7 +335,7 @@ func NewFlowToolsExecutor(cfg *config.Config,docker docker.DockerClient,functions *Functions,- flowID int64,+ userID, flowID int64,) (FlowToolsExecutor, error) {allPatterns, err := patterns.LoadPatterns(patterns.PatternListTypeAll)if err != nil {@@ -348,11 +357,16 @@ func NewFlowToolsExecutor(replacer: replacer,cfg: cfg,flowID: flowID,+ userID: userID,definitions: make(map[string]llms.FunctionDefinition),handlers: make(map[string]ExecutorHandler),}, nil}+func (fte *flowToolsExecutor) SetUserID(userID int64) {+ fte.userID = userID+}+func (fte *flowToolsExecutor) SetFlowID(flowID int64) {fte.flowID = flowID}@@ -374,6 +388,7 @@ func (fte *flowToolsExecutor) SetEmbedder(embedder embeddings.Embedder) {context.Background(),pgvector.WithConnectionURL(fte.cfg.DatabaseURL),pgvector.WithEmbedder(embedder),+ pgvector.WithCollectionName("langchain"),)if err == nil {fte.store = &store@@ -408,6 +423,10 @@ func (fte *flowToolsExecutor) SetVectorStoreLogProvider(vslp VectorStoreLogProvifte.vslp = vslp}+func (fte *flowToolsExecutor) SetKnowledgeProvider(knp KnowledgeProvider) {+ fte.knp = knp+}+func (fte *flowToolsExecutor) SetGraphitiClient(client *graphiti.Client) {fte.graphitiClient = client}@@ -703,6 +722,7 @@ func (fte *flowToolsExecutor) GetCustomExecutor(cfg CustomExecutorConfig) (Conte}return &customExecutor{+ userID: fte.userID,flowID: fte.flowID,taskID: cfg.TaskID,subtaskID: cfg.SubtaskID,@@ -804,10 +824,11 @@ func (fte *flowToolsExecutor) GetAssistantExecutor(cfg AssistantExecutorConfig)}guide := NewGuideTool(- fte.flowID, nil, nil,+ fte.userID, fte.flowID, nil, nil,fte.replacer,fte.store,fte.vslp,+ fte.knp,)if guide.IsAvailable() {definitions = append(definitions, registryDefinitions[SearchGuideToolName])@@ -815,10 +836,11 @@ func (fte *flowToolsExecutor) GetAssistantExecutor(cfg AssistantExecutorConfig)}search := NewSearchTool(- fte.flowID, nil, nil,+ fte.userID, fte.flowID, nil, nil,fte.replacer,fte.store,fte.vslp,+ fte.knp,)if search.IsAvailable() {definitions = append(definitions, registryDefinitions[SearchAnswerToolName])@@ -826,10 +848,11 @@ func (fte *flowToolsExecutor) GetAssistantExecutor(cfg AssistantExecutorConfig)}code := NewCodeTool(- fte.flowID, nil, nil,+ fte.userID, fte.flowID, nil, nil,fte.replacer,fte.store,fte.vslp,+ fte.knp,)if code.IsAvailable() {definitions = append(definitions, registryDefinitions[SearchCodeToolName])@@ -933,6 +956,7 @@ func (fte *flowToolsExecutor) GetAssistantExecutor(cfg AssistantExecutorConfig)}ce := &customExecutor{+ userID: fte.userID,flowID: fte.flowID,mlp: fte.mlp,vslp: fte.vslp,@@ -977,6 +1001,7 @@ func (fte *flowToolsExecutor) GetPrimaryExecutor(cfg PrimaryExecutorConfig) (Con}ce := &customExecutor{+ userID: fte.userID,flowID: fte.flowID,taskID: &cfg.TaskID,subtaskID: &cfg.SubtaskID,@@ -1051,6 +1076,7 @@ func (fte *flowToolsExecutor) GetInstallerExecutor(cfg InstallerExecutorConfig))ce := &customExecutor{+ userID: fte.userID,flowID: fte.flowID,taskID: cfg.TaskID,subtaskID: cfg.SubtaskID,@@ -1095,12 +1121,14 @@ func (fte *flowToolsExecutor) GetInstallerExecutor(cfg InstallerExecutorConfig)}guide := NewGuideTool(+ fte.userID,fte.flowID,cfg.TaskID,cfg.SubtaskID,fte.replacer,fte.store,fte.vslp,+ fte.knp,)if guide.IsAvailable() {ce.definitions = append(ce.definitions, registryDefinitions[StoreGuideToolName])@@ -1150,6 +1178,7 @@ func (fte *flowToolsExecutor) GetCoderExecutor(cfg CoderExecutorConfig) (Context)ce := &customExecutor{+ userID: fte.userID,flowID: fte.flowID,taskID: cfg.TaskID,subtaskID: cfg.SubtaskID,@@ -1196,12 +1225,14 @@ func (fte *flowToolsExecutor) GetCoderExecutor(cfg CoderExecutorConfig) (Context}code := NewCodeTool(+ fte.userID,fte.flowID,cfg.TaskID,cfg.SubtaskID,fte.replacer,fte.store,fte.vslp,+ fte.knp,)if code.IsAvailable() {ce.definitions = append(ce.definitions, registryDefinitions[SearchCodeToolName])@@ -1266,6 +1297,7 @@ func (fte *flowToolsExecutor) GetPentesterExecutor(cfg PentesterExecutorConfig))ce := &customExecutor{+ userID: fte.userID,flowID: fte.flowID,taskID: cfg.TaskID,subtaskID: cfg.SubtaskID,@@ -1314,12 +1346,14 @@ func (fte *flowToolsExecutor) GetPentesterExecutor(cfg PentesterExecutorConfig)}guide := NewGuideTool(+ fte.userID,fte.flowID,cfg.TaskID,cfg.SubtaskID,fte.replacer,fte.store,fte.vslp,+ fte.knp,)if guide.IsAvailable() {ce.definitions = append(ce.definitions, registryDefinitions[StoreGuideToolName])@@ -1364,6 +1398,7 @@ func (fte *flowToolsExecutor) GetSearcherExecutor(cfg SearcherExecutorConfig) (C}ce := &customExecutor{+ userID: fte.userID,flowID: fte.flowID,taskID: cfg.TaskID,subtaskID: cfg.SubtaskID,@@ -1487,12 +1522,14 @@ func (fte *flowToolsExecutor) GetSearcherExecutor(cfg SearcherExecutorConfig) (C}search := NewSearchTool(+ fte.userID,fte.flowID,cfg.TaskID,cfg.SubtaskID,fte.replacer,fte.store,fte.vslp,+ fte.knp,)if search.IsAvailable() {ce.definitions = append(ce.definitions, registryDefinitions[SearchAnswerToolName])@@ -1530,6 +1567,7 @@ func (fte *flowToolsExecutor) GetGeneratorExecutor(cfg GeneratorExecutorConfig))ce := &customExecutor{+ userID: fte.userID,flowID: fte.flowID,taskID: &cfg.TaskID,mlp: fte.mlp,@@ -1596,6 +1634,7 @@ func (fte *flowToolsExecutor) GetRefinerExecutor(cfg RefinerExecutorConfig) (Con)ce := &customExecutor{+ userID: fte.userID,flowID: fte.flowID,taskID: &cfg.TaskID,mlp: fte.mlp,@@ -1658,6 +1697,7 @@ func (fte *flowToolsExecutor) GetMemoristExecutor(cfg MemoristExecutorConfig) (C)ce := &customExecutor{+ userID: fte.userID,flowID: fte.flowID,taskID: cfg.TaskID,subtaskID: cfg.SubtaskID,@@ -1727,6 +1767,7 @@ func (fte *flowToolsExecutor) GetEnricherExecutor(cfg EnricherExecutorConfig) (C)ce := &customExecutor{+ userID: fte.userID,flowID: fte.flowID,taskID: cfg.TaskID,subtaskID: cfg.SubtaskID,@@ -1794,6 +1835,7 @@ func (fte *flowToolsExecutor) GetReporterExecutor(cfg ReporterExecutorConfig) (C}return &customExecutor{+ userID: fte.userID,flowID: fte.flowID,taskID: cfg.TaskID,subtaskID: cfg.SubtaskID,diff --git a/backend/sqlc/models/knowledge.sql b/backend/sqlc/models/knowledge.sqlnew file mode 100644index 00000000..1c859dc0--- /dev/null+++ b/backend/sqlc/models/knowledge.sql@@ -0,0 +1,99 @@+-- name: GetKnowledgeDocument :one+-- Fetch a single knowledge document by its UUID (admin view — no user_id check).+SELECT+ e.uuid::text AS id,+ COALESCE(e.document, '') AS document,+ COALESCE(e.cmetadata::text, '{}') AS cmetadata+FROM langchain_pg_embedding e+INNER JOIN langchain_pg_collection c ON e.collection_id = c.uuid+WHERE c.name = 'langchain'+ AND e.uuid::text = $1;++-- name: GetUserKnowledgeDocument :one+-- Fetch a single knowledge document by UUID, scoped to a specific user.+SELECT+ e.uuid::text AS id,+ COALESCE(e.document, '') AS document,+ COALESCE(e.cmetadata::text, '{}') AS cmetadata+FROM langchain_pg_embedding e+INNER JOIN langchain_pg_collection c ON e.collection_id = c.uuid+WHERE c.name = 'langchain'+ AND e.uuid::text = $1+ AND (e.cmetadata ->> 'user_id') = $2;++-- name: ListAllKnowledgeDocuments :many+-- List all knowledge documents excluding the noisy memory type (admin view).+SELECT+ e.uuid::text AS id,+ COALESCE(e.document, '') AS document,+ COALESCE(e.cmetadata::text, '{}') AS cmetadata+FROM langchain_pg_embedding e+INNER JOIN langchain_pg_collection c ON e.collection_id = c.uuid+WHERE c.name = 'langchain'+ AND COALESCE(e.cmetadata ->> 'doc_type', '') NOT IN ('memory')+ORDER BY e.uuid;++-- name: ListFlowKnowledgeDocuments :many+-- List non-memory knowledge documents belonging to a specific flow (admin scoped).+SELECT+ e.uuid::text AS id,+ COALESCE(e.document, '') AS document,+ COALESCE(e.cmetadata::text, '{}') AS cmetadata+FROM langchain_pg_embedding e+INNER JOIN langchain_pg_collection c ON e.collection_id = c.uuid+WHERE c.name = 'langchain'+ AND COALESCE(e.cmetadata ->> 'doc_type', '') NOT IN ('memory')+ AND (e.cmetadata ->> 'flow_id') = $1+ORDER BY e.uuid;++-- name: ListUserKnowledgeDocuments :many+-- List all non-memory knowledge documents owned by a specific user (user-scoped view).+SELECT+ e.uuid::text AS id,+ COALESCE(e.document, '') AS document,+ COALESCE(e.cmetadata::text, '{}') AS cmetadata+FROM langchain_pg_embedding e+INNER JOIN langchain_pg_collection c ON e.collection_id = c.uuid+WHERE c.name = 'langchain'+ AND COALESCE(e.cmetadata ->> 'doc_type', '') NOT IN ('memory')+ AND (e.cmetadata ->> 'user_id') = $1+ORDER BY e.uuid;++-- name: UpdateKnowledgeDocument :one+-- Update an existing document's embedding, text and metadata atomically.+-- $2 must be formatted as a PostgreSQL vector literal: '[f1,f2,...]'+-- $4 must be valid JSON text.+UPDATE langchain_pg_embedding+SET+ embedding = $2::vector,+ document = $3,+ cmetadata = $4::json+WHERE uuid::text = $1+ AND collection_id = (SELECT uuid FROM langchain_pg_collection WHERE name = 'langchain')+RETURNING+ uuid::text AS id,+ COALESCE(document, '') AS document,+ COALESCE(cmetadata::text, '{}') AS cmetadata;++-- name: DeleteKnowledgeDocument :exec+-- Delete a knowledge document by UUID (admin — no user_id check).+DELETE FROM langchain_pg_embedding+WHERE uuid::text = $1+ AND collection_id = (SELECT uuid FROM langchain_pg_collection WHERE name = 'langchain');++-- name: DeleteUserKnowledgeDocument :exec+-- Delete a knowledge document by UUID, only if it belongs to the given user.+DELETE FROM langchain_pg_embedding+WHERE uuid::text = $1+ AND (cmetadata ->> 'user_id') = $2+ AND collection_id = (SELECT uuid FROM langchain_pg_collection WHERE name = 'langchain');++-- name: DeleteFlowMemoryDocuments :exec+-- Delete all memory-type documents for a specific flow.+-- Called on flow deletion to free long-term memory that will never be re-used.+-- $1 is the decimal text representation of the flow ID (e.g. "55"), matching the+-- text result of (cmetadata ->> 'flow_id') which uses JSON ->> extraction.+DELETE FROM langchain_pg_embedding+WHERE collection_id = (SELECT uuid FROM langchain_pg_collection WHERE name = 'langchain')+ AND COALESCE(cmetadata ->> 'doc_type', '') = 'memory'+ AND (cmetadata ->> 'flow_id') = $1;diff --git a/backend/sqlc/sqlc.yml b/backend/sqlc/sqlc.ymlindex eb4530f1..21e0d0da 100644--- a/backend/sqlc/sqlc.yml+++ b/backend/sqlc/sqlc.yml@@ -23,6 +23,14 @@ sql:go_type: "float64"- db_type: "bigint"go_type: "int64"+ # pgvector extension type — never selected in queries, but sqlc needs a mapping+ # to generate the LangchainPgEmbedding model struct in models.go.+ - db_type: "pg_catalog.vector"+ go_type: "string"+ nullable: true+ - db_type: "vector"+ go_type: "string"+ nullable: true# Database connection for sqlc analysisdatabase:diff --git a/frontend/graphql-schema.graphql b/frontend/graphql-schema.graphqlindex feff3487..f571e02f 100644--- a/frontend/graphql-schema.graphql+++ b/frontend/graphql-schema.graphql@@ -494,6 +494,31 @@ fragment flowExecutionStatsFragment on FlowExecutionStats {}}+fragment knowledgeDocumentFragment on KnowledgeDocument {+ id+ docType+ content+ question+ description+ userId+ flowId+ taskId+ subtaskId+ guideType+ answerType+ codeLang+ partSize+ totalSize+ manual+}++fragment knowledgeDocumentWithScoreFragment on KnowledgeDocumentWithScore {+ score+ document {+ ...knowledgeDocumentFragment+ }+}+# ==================== Queries ====================query flows {@@ -939,6 +964,26 @@ query apiToken($tokenId: String!) {}}+# ==================== Knowledge ====================++query knowledgeDocuments($filter: KnowledgeFilter, $withContent: Boolean!) {+ knowledgeDocuments(filter: $filter, withContent: $withContent) {+ ...knowledgeDocumentFragment+ }+}++query knowledgeDocument($id: String!) {+ knowledgeDocument(id: $id) {+ ...knowledgeDocumentFragment+ }+}++query searchKnowledge($query: String!, $filter: KnowledgeFilter, $limit: Int) {+ searchKnowledge(query: $query, filter: $filter, limit: $limit) {+ ...knowledgeDocumentWithScoreFragment+ }+}+fragment userPreferencesFragment on UserPreferences {idfavoriteFlows@@ -1111,6 +1156,22 @@ mutation deleteAPIToken($tokenId: String!) {deleteAPIToken(tokenId: $tokenId)}+mutation createKnowledgeDocument($input: CreateKnowledgeDocumentInput!) {+ createKnowledgeDocument(input: $input) {+ ...knowledgeDocumentFragment+ }+}++mutation updateKnowledgeDocument($id: String!, $input: UpdateKnowledgeDocumentInput!) {+ updateKnowledgeDocument(id: $id, input: $input) {+ ...knowledgeDocumentFragment+ }+}++mutation deleteKnowledgeDocument($id: String!) {+ deleteKnowledgeDocument(id: $id)+}+# ==================== Subscriptions ====================subscription terminalLogAdded($flowId: ID!) {@@ -1316,3 +1377,21 @@ subscription resourceDeleted {...userResourceFragment}}++subscription knowledgeDocumentCreated {+ knowledgeDocumentCreated {+ ...knowledgeDocumentFragment+ }+}++subscription knowledgeDocumentUpdated {+ knowledgeDocumentUpdated {+ ...knowledgeDocumentFragment+ }+}++subscription knowledgeDocumentDeleted {+ knowledgeDocumentDeleted {+ ...knowledgeDocumentFragment+ }+}diff --git a/frontend/src/graphql/types.ts b/frontend/src/graphql/types.tsindex 299bea6f..003f1e7f 100644--- a/frontend/src/graphql/types.ts+++ b/frontend/src/graphql/types.ts@@ -221,6 +221,16 @@ export type CreateFlowTemplateInput = {title: Scalars['String']['input'];};+export type CreateKnowledgeDocumentInput = {+ answerType?: InputMaybe<KnowledgeAnswerType>;+ codeLang?: InputMaybe<Scalars['String']['input']>;+ content: Scalars['String']['input'];+ description?: InputMaybe<Scalars['String']['input']>;+ docType: KnowledgeDocType;+ guideType?: InputMaybe<KnowledgeGuideType>;+ question: Scalars['String']['input'];+};+export type DailyFlowsStats = {date: Scalars['Time']['output'];stats: FlowsStats;@@ -323,6 +333,61 @@ export type FunctionToolcallsStats = {totalDurationSeconds: Scalars['Float']['output'];};+export enum KnowledgeAnswerType {+ Code = 'code',+ Guide = 'guide',+ Other = 'other',+ Tool = 'tool',+ Vulnerability = 'vulnerability',+}++export enum KnowledgeDocType {+ Answer = 'answer',+ Code = 'code',+ Guide = 'guide',+}++export type KnowledgeDocument = {+ answerType?: Maybe<KnowledgeAnswerType>;+ codeLang?: Maybe<Scalars['String']['output']>;+ content: Scalars['String']['output'];+ description?: Maybe<Scalars['String']['output']>;+ docType: KnowledgeDocType;+ flowId?: Maybe<Scalars['ID']['output']>;+ guideType?: Maybe<KnowledgeGuideType>;+ id: Scalars['String']['output'];+ manual: Scalars['Boolean']['output'];+ partSize: Scalars['Int']['output'];+ question: Scalars['String']['output'];+ subtaskId?: Maybe<Scalars['ID']['output']>;+ taskId?: Maybe<Scalars['ID']['output']>;+ totalSize: Scalars['Int']['output'];+ userId: Scalars['ID']['output'];+};++export type KnowledgeDocumentWithScore = {+ document: KnowledgeDocument;+ score: Scalars['Float']['output'];+};++export type KnowledgeFilter = {+ answerTypes?: InputMaybe<Array<KnowledgeAnswerType>>;+ codeLangs?: InputMaybe<Array<Scalars['String']['input']>>;+ docTypes?: InputMaybe<Array<KnowledgeDocType>>;+ flowId?: InputMaybe<Scalars['ID']['input']>;+ guideTypes?: InputMaybe<Array<KnowledgeGuideType>>;+ manual?: InputMaybe<Scalars['Boolean']['input']>;+};++export enum KnowledgeGuideType {+ Configure = 'configure',+ Development = 'development',+ Install = 'install',+ Other = 'other',+ Pentest = 'pentest',+ Use = 'use',+}+export type MessageLog = {createdAt: Scalars['Time']['output'];flowId: Scalars['ID']['output'];@@ -392,6 +457,7 @@ export type Mutation = {createAssistant: FlowAssistant;createFlow: Flow;createFlowTemplate: FlowTemplate;+ createKnowledgeDocument: KnowledgeDocument;createPrompt: UserPrompt;createProvider: ProviderConfig;deleteAPIToken: Scalars['Boolean']['output'];@@ -399,6 +465,7 @@ export type Mutation = {deleteFavoriteFlow: ResultType;deleteFlow: ResultType;deleteFlowTemplate: ResultType;+ deleteKnowledgeDocument: ResultType;deletePrompt: ResultType;deleteProvider: ResultType;finishFlow: ResultType;@@ -410,6 +477,7 @@ export type Mutation = {testProvider: ProviderTestResult;updateAPIToken: ApiToken;updateFlowTemplate: FlowTemplate;+ updateKnowledgeDocument: KnowledgeDocument;updatePrompt: UserPrompt;updateProvider: ProviderConfig;validatePrompt: PromptValidationResult;@@ -449,6 +517,10 @@ export type MutationCreateFlowTemplateArgs = {input: CreateFlowTemplateInput;};+export type MutationCreateKnowledgeDocumentArgs = {+ input: CreateKnowledgeDocumentInput;+};+export type MutationCreatePromptArgs = {template: Scalars['String']['input'];type: PromptType;@@ -481,6 +553,10 @@ export type MutationDeleteFlowTemplateArgs = {templateId: Scalars['ID']['input'];};+export type MutationDeleteKnowledgeDocumentArgs = {+ id: Scalars['String']['input'];+};+export type MutationDeletePromptArgs = {promptId: Scalars['ID']['input'];};@@ -535,6 +611,11 @@ export type MutationUpdateFlowTemplateArgs = {templateId: Scalars['ID']['input'];};+export type MutationUpdateKnowledgeDocumentArgs = {+ id: Scalars['String']['input'];+ input: UpdateKnowledgeDocumentInput;+};+export type MutationUpdatePromptArgs = {promptId: Scalars['ID']['input'];template: Scalars['String']['input'];@@ -711,10 +792,13 @@ export type Query = {flowsExecutionStatsByPeriod: Array<FlowExecutionStats>;flowsStatsByPeriod: Array<DailyFlowsStats>;flowsStatsTotal: FlowsStats;+ knowledgeDocument: KnowledgeDocument;+ knowledgeDocuments: Array<KnowledgeDocument>;messageLogs?: Maybe<Array<MessageLog>>;providers: Array<Provider>;resources: Array<UserResource>;screenshots?: Maybe<Array<Screenshot>>;+ searchKnowledge: Array<KnowledgeDocumentWithScore>;searchLogs?: Maybe<Array<SearchLog>>;settings: Settings;settingsPrompts: PromptsConfig;@@ -779,6 +863,15 @@ export type QueryFlowsStatsByPeriodArgs = {period: UsageStatsPeriod;};+export type QueryKnowledgeDocumentArgs = {+ id: Scalars['String']['input'];+};++export type QueryKnowledgeDocumentsArgs = {+ filter?: InputMaybe<KnowledgeFilter>;+ withContent: Scalars['Boolean']['input'];+};+export type QueryMessageLogsArgs = {flowId: Scalars['ID']['input'];};@@ -792,6 +885,12 @@ export type QueryScreenshotsArgs = {flowId: Scalars['ID']['input'];};+export type QuerySearchKnowledgeArgs = {+ filter?: InputMaybe<KnowledgeFilter>;+ limit?: InputMaybe<Scalars['Int']['input']>;+ query: Scalars['String']['input'];+};+export type QuerySearchLogsArgs = {flowId: Scalars['ID']['input'];};@@ -920,6 +1019,9 @@ export type Subscription = {flowTemplateDeleted: FlowTemplate;flowTemplateUpdated: FlowTemplate;flowUpdated: Flow;+ knowledgeDocumentCreated: KnowledgeDocument;+ knowledgeDocumentDeleted: KnowledgeDocument;+ knowledgeDocumentUpdated: KnowledgeDocument;messageLogAdded: MessageLog;messageLogUpdated: MessageLog;providerCreated: ProviderConfig;@@ -1120,6 +1222,15 @@ export type UpdateFlowTemplateInput = {title: Scalars['String']['input'];};+export type UpdateKnowledgeDocumentInput = {+ answerType?: InputMaybe<KnowledgeAnswerType>;+ codeLang?: InputMaybe<Scalars['String']['input']>;+ content: Scalars['String']['input'];+ description?: InputMaybe<Scalars['String']['input']>;+ guideType?: InputMaybe<KnowledgeGuideType>;+ question?: InputMaybe<Scalars['String']['input']>;+};+export type UsageStats = {totalUsageCacheIn: Scalars['Int']['output'];totalUsageCacheOut: Scalars['Int']['output'];@@ -1546,6 +1657,26 @@ export type FlowExecutionStatsFragmentFragment = {tasks: Array<TaskExecutionStatsFragmentFragment>;};+export type KnowledgeDocumentFragmentFragment = {+ id: string;+ docType: KnowledgeDocType;+ content: string;+ question: string;+ description?: string | null;+ userId: string;+ flowId?: string | null;+ taskId?: string | null;+ subtaskId?: string | null;+ guideType?: KnowledgeGuideType | null;+ answerType?: KnowledgeAnswerType | null;+ codeLang?: string | null;+ partSize: number;+ totalSize: number;+ manual: boolean;+};++export type KnowledgeDocumentWithScoreFragmentFragment = { score: number; document: KnowledgeDocumentFragmentFragment };+export type FlowsQueryVariables = Exact<{ [key: string]: never }>;export type FlowsQuery = { flows?: Array<FlowFragmentFragment> | null };@@ -1802,6 +1933,27 @@ export type ApiTokenQueryVariables = Exact<{export type ApiTokenQuery = { apiToken?: ApiTokenFragmentFragment | null };+export type KnowledgeDocumentsQueryVariables = Exact<{+ filter?: InputMaybe<KnowledgeFilter>;+ withContent: Scalars['Boolean']['input'];+}>;++export type KnowledgeDocumentsQuery = { knowledgeDocuments: Array<KnowledgeDocumentFragmentFragment> };++export type KnowledgeDocumentQueryVariables = Exact<{+ id: Scalars['String']['input'];+}>;++export type KnowledgeDocumentQuery = { knowledgeDocument: KnowledgeDocumentFragmentFragment };++export type SearchKnowledgeQueryVariables = Exact<{+ query: Scalars['String']['input'];+ filter?: InputMaybe<KnowledgeFilter>;+ limit?: InputMaybe<Scalars['Int']['input']>;+}>;++export type SearchKnowledgeQuery = { searchKnowledge: Array<KnowledgeDocumentWithScoreFragmentFragment> };+export type UserPreferencesFragmentFragment = { id: string; favoriteFlows: Array<string> };export type SettingsUserQueryVariables = Exact<{ [key: string]: never }>;@@ -2010,6 +2162,25 @@ export type DeleteApiTokenMutationVariables = Exact<{export type DeleteApiTokenMutation = { deleteAPIToken: boolean };+export type CreateKnowledgeDocumentMutationVariables = Exact<{+ input: CreateKnowledgeDocumentInput;+}>;++export type CreateKnowledgeDocumentMutation = { createKnowledgeDocument: KnowledgeDocumentFragmentFragment };++export type UpdateKnowledgeDocumentMutationVariables = Exact<{+ id: Scalars['String']['input'];+ input: UpdateKnowledgeDocumentInput;+}>;++export type UpdateKnowledgeDocumentMutation = { updateKnowledgeDocument: KnowledgeDocumentFragmentFragment };++export type DeleteKnowledgeDocumentMutationVariables = Exact<{+ id: Scalars['String']['input'];+}>;++export type DeleteKnowledgeDocumentMutation = { deleteKnowledgeDocument: ResultType };+export type TerminalLogAddedSubscriptionVariables = Exact<{flowId: Scalars['ID']['input'];}>;@@ -2184,6 +2355,18 @@ export type ResourceDeletedSubscriptionVariables = Exact<{ [key: string]: neverexport type ResourceDeletedSubscription = { resourceDeleted: UserResourceFragmentFragment };+export type KnowledgeDocumentCreatedSubscriptionVariables = Exact<{ [key: string]: never }>;++export type KnowledgeDocumentCreatedSubscription = { knowledgeDocumentCreated: KnowledgeDocumentFragmentFragment };++export type KnowledgeDocumentUpdatedSubscriptionVariables = Exact<{ [key: string]: never }>;++export type KnowledgeDocumentUpdatedSubscription = { knowledgeDocumentUpdated: KnowledgeDocumentFragmentFragment };++export type KnowledgeDocumentDeletedSubscriptionVariables = Exact<{ [key: string]: never }>;++export type KnowledgeDocumentDeletedSubscription = { knowledgeDocumentDeleted: KnowledgeDocumentFragmentFragment };+export const SettingsFragmentFragmentDoc = gql`fragment settingsFragment on Settings {debug@@ -2739,6 +2922,34 @@ export const FlowExecutionStatsFragmentFragmentDoc = gql`}${TaskExecutionStatsFragmentFragmentDoc}`;+export const KnowledgeDocumentFragmentFragmentDoc = gql`+ fragment knowledgeDocumentFragment on KnowledgeDocument {+ id+ docType+ content+ question+ description+ userId+ flowId+ taskId+ subtaskId+ guideType+ answerType+ codeLang+ partSize+ totalSize+ manual+ }+`;+export const KnowledgeDocumentWithScoreFragmentFragmentDoc = gql`+ fragment knowledgeDocumentWithScoreFragment on KnowledgeDocumentWithScore {+ score+ document {+ ...knowledgeDocumentFragment+ }+ }+ ${KnowledgeDocumentFragmentFragmentDoc}+`;export const UserPreferencesFragmentFragmentDoc = gql`fragment userPreferencesFragment on UserPreferences {id@@ -5004,6 +5215,207 @@ export type ApiTokenQueryHookResult = ReturnType<typeof useApiTokenQuery>;export type ApiTokenLazyQueryHookResult = ReturnType<typeof useApiTokenLazyQuery>;export type ApiTokenSuspenseQueryHookResult = ReturnType<typeof useApiTokenSuspenseQuery>;export type ApiTokenQueryResult = Apollo.QueryResult<ApiTokenQuery, ApiTokenQueryVariables>;+export const KnowledgeDocumentsDocument = gql`+ query knowledgeDocuments($filter: KnowledgeFilter, $withContent: Boolean!) {+ knowledgeDocuments(filter: $filter, withContent: $withContent) {+ ...knowledgeDocumentFragment+ }+ }+ ${KnowledgeDocumentFragmentFragmentDoc}+`;++/**+ * __useKnowledgeDocumentsQuery__+ *+ * To run a query within a React component, call `useKnowledgeDocumentsQuery` and pass it any options that fit your needs.+ * When your component renders, `useKnowledgeDocumentsQuery` returns an object from Apollo Client that contains loading, error, and data properties+ * you can use to render your UI.+ *+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;+ *+ * @example+ * const { data, loading, error } = useKnowledgeDocumentsQuery({+ * variables: {+ * filter: // value for 'filter'+ * withContent: // value for 'withContent'+ * },+ * });+ */+export function useKnowledgeDocumentsQuery(+ baseOptions: Apollo.QueryHookOptions<KnowledgeDocumentsQuery, KnowledgeDocumentsQueryVariables> &+ ({ variables: KnowledgeDocumentsQueryVariables; skip?: boolean } | { skip: boolean }),+) {+ const options = { ...defaultOptions, ...baseOptions };+ return Apollo.useQuery<KnowledgeDocumentsQuery, KnowledgeDocumentsQueryVariables>(+ KnowledgeDocumentsDocument,+ options,+ );+}+export function useKnowledgeDocumentsLazyQuery(+ baseOptions?: Apollo.LazyQueryHookOptions<KnowledgeDocumentsQuery, KnowledgeDocumentsQueryVariables>,+) {+ const options = { ...defaultOptions, ...baseOptions };+ return Apollo.useLazyQuery<KnowledgeDocumentsQuery, KnowledgeDocumentsQueryVariables>(+ KnowledgeDocumentsDocument,+ options,+ );+}+// @ts-ignore+export function useKnowledgeDocumentsSuspenseQuery(+ baseOptions?: Apollo.SuspenseQueryHookOptions<KnowledgeDocumentsQuery, KnowledgeDocumentsQueryVariables>,+): Apollo.UseSuspenseQueryResult<KnowledgeDocumentsQuery, KnowledgeDocumentsQueryVariables>;+export function useKnowledgeDocumentsSuspenseQuery(+ baseOptions?:+ | Apollo.SkipToken+ | Apollo.SuspenseQueryHookOptions<KnowledgeDocumentsQuery, KnowledgeDocumentsQueryVariables>,+): Apollo.UseSuspenseQueryResult<KnowledgeDocumentsQuery | undefined, KnowledgeDocumentsQueryVariables>;+export function useKnowledgeDocumentsSuspenseQuery(+ baseOptions?:+ | Apollo.SkipToken+ | Apollo.SuspenseQueryHookOptions<KnowledgeDocumentsQuery, KnowledgeDocumentsQueryVariables>,+) {+ const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };+ return Apollo.useSuspenseQuery<KnowledgeDocumentsQuery, KnowledgeDocumentsQueryVariables>(+ KnowledgeDocumentsDocument,+ options,+ );+}+export type KnowledgeDocumentsQueryHookResult = ReturnType<typeof useKnowledgeDocumentsQuery>;+export type KnowledgeDocumentsLazyQueryHookResult = ReturnType<typeof useKnowledgeDocumentsLazyQuery>;+export type KnowledgeDocumentsSuspenseQueryHookResult = ReturnType<typeof useKnowledgeDocumentsSuspenseQuery>;+export type KnowledgeDocumentsQueryResult = Apollo.QueryResult<+ KnowledgeDocumentsQuery,+ KnowledgeDocumentsQueryVariables+>;+export const KnowledgeDocumentDocument = gql`+ query knowledgeDocument($id: String!) {+ knowledgeDocument(id: $id) {+ ...knowledgeDocumentFragment+ }+ }+ ${KnowledgeDocumentFragmentFragmentDoc}+`;++/**+ * __useKnowledgeDocumentQuery__+ *+ * To run a query within a React component, call `useKnowledgeDocumentQuery` and pass it any options that fit your needs.+ * When your component renders, `useKnowledgeDocumentQuery` returns an object from Apollo Client that contains loading, error, and data properties+ * you can use to render your UI.+ *+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;+ *+ * @example+ * const { data, loading, error } = useKnowledgeDocumentQuery({+ * variables: {+ * id: // value for 'id'+ * },+ * });+ */+export function useKnowledgeDocumentQuery(+ baseOptions: Apollo.QueryHookOptions<KnowledgeDocumentQuery, KnowledgeDocumentQueryVariables> &+ ({ variables: KnowledgeDocumentQueryVariables; skip?: boolean } | { skip: boolean }),+) {+ const options = { ...defaultOptions, ...baseOptions };+ return Apollo.useQuery<KnowledgeDocumentQuery, KnowledgeDocumentQueryVariables>(KnowledgeDocumentDocument, options);+}+export function useKnowledgeDocumentLazyQuery(+ baseOptions?: Apollo.LazyQueryHookOptions<KnowledgeDocumentQuery, KnowledgeDocumentQueryVariables>,+) {+ const options = { ...defaultOptions, ...baseOptions };+ return Apollo.useLazyQuery<KnowledgeDocumentQuery, KnowledgeDocumentQueryVariables>(+ KnowledgeDocumentDocument,+ options,+ );+}+// @ts-ignore+export function useKnowledgeDocumentSuspenseQuery(+ baseOptions?: Apollo.SuspenseQueryHookOptions<KnowledgeDocumentQuery, KnowledgeDocumentQueryVariables>,+): Apollo.UseSuspenseQueryResult<KnowledgeDocumentQuery, KnowledgeDocumentQueryVariables>;+export function useKnowledgeDocumentSuspenseQuery(+ baseOptions?:+ | Apollo.SkipToken+ | Apollo.SuspenseQueryHookOptions<KnowledgeDocumentQuery, KnowledgeDocumentQueryVariables>,+): Apollo.UseSuspenseQueryResult<KnowledgeDocumentQuery | undefined, KnowledgeDocumentQueryVariables>;+export function useKnowledgeDocumentSuspenseQuery(+ baseOptions?:+ | Apollo.SkipToken+ | Apollo.SuspenseQueryHookOptions<KnowledgeDocumentQuery, KnowledgeDocumentQueryVariables>,+) {+ const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };+ return Apollo.useSuspenseQuery<KnowledgeDocumentQuery, KnowledgeDocumentQueryVariables>(+ KnowledgeDocumentDocument,+ options,+ );+}+export type KnowledgeDocumentQueryHookResult = ReturnType<typeof useKnowledgeDocumentQuery>;+export type KnowledgeDocumentLazyQueryHookResult = ReturnType<typeof useKnowledgeDocumentLazyQuery>;+export type KnowledgeDocumentSuspenseQueryHookResult = ReturnType<typeof useKnowledgeDocumentSuspenseQuery>;+export type KnowledgeDocumentQueryResult = Apollo.QueryResult<KnowledgeDocumentQuery, KnowledgeDocumentQueryVariables>;+export const SearchKnowledgeDocument = gql`+ query searchKnowledge($query: String!, $filter: KnowledgeFilter, $limit: Int) {+ searchKnowledge(query: $query, filter: $filter, limit: $limit) {+ ...knowledgeDocumentWithScoreFragment+ }+ }+ ${KnowledgeDocumentWithScoreFragmentFragmentDoc}+`;++/**+ * __useSearchKnowledgeQuery__+ *+ * To run a query within a React component, call `useSearchKnowledgeQuery` and pass it any options that fit your needs.+ * When your component renders, `useSearchKnowledgeQuery` returns an object from Apollo Client that contains loading, error, and data properties+ * you can use to render your UI.+ *+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;+ *+ * @example+ * const { data, loading, error } = useSearchKnowledgeQuery({+ * variables: {+ * query: // value for 'query'+ * filter: // value for 'filter'+ * limit: // value for 'limit'+ * },+ * });+ */+export function useSearchKnowledgeQuery(+ baseOptions: Apollo.QueryHookOptions<SearchKnowledgeQuery, SearchKnowledgeQueryVariables> &+ ({ variables: SearchKnowledgeQueryVariables; skip?: boolean } | { skip: boolean }),+) {+ const options = { ...defaultOptions, ...baseOptions };+ return Apollo.useQuery<SearchKnowledgeQuery, SearchKnowledgeQueryVariables>(SearchKnowledgeDocument, options);+}+export function useSearchKnowledgeLazyQuery(+ baseOptions?: Apollo.LazyQueryHookOptions<SearchKnowledgeQuery, SearchKnowledgeQueryVariables>,+) {+ const options = { ...defaultOptions, ...baseOptions };+ return Apollo.useLazyQuery<SearchKnowledgeQuery, SearchKnowledgeQueryVariables>(SearchKnowledgeDocument, options);+}+// @ts-ignore+export function useSearchKnowledgeSuspenseQuery(+ baseOptions?: Apollo.SuspenseQueryHookOptions<SearchKnowledgeQuery, SearchKnowledgeQueryVariables>,+): Apollo.UseSuspenseQueryResult<SearchKnowledgeQuery, SearchKnowledgeQueryVariables>;+export function useSearchKnowledgeSuspenseQuery(+ baseOptions?:+ | Apollo.SkipToken+ | Apollo.SuspenseQueryHookOptions<SearchKnowledgeQuery, SearchKnowledgeQueryVariables>,+): Apollo.UseSuspenseQueryResult<SearchKnowledgeQuery | undefined, SearchKnowledgeQueryVariables>;+export function useSearchKnowledgeSuspenseQuery(+ baseOptions?:+ | Apollo.SkipToken+ | Apollo.SuspenseQueryHookOptions<SearchKnowledgeQuery, SearchKnowledgeQueryVariables>,+) {+ const options = baseOptions === Apollo.skipToken ? baseOptions : { ...defaultOptions, ...baseOptions };+ return Apollo.useSuspenseQuery<SearchKnowledgeQuery, SearchKnowledgeQueryVariables>(+ SearchKnowledgeDocument,+ options,+ );+}+export type SearchKnowledgeQueryHookResult = ReturnType<typeof useSearchKnowledgeQuery>;+export type SearchKnowledgeLazyQueryHookResult = ReturnType<typeof useSearchKnowledgeLazyQuery>;+export type SearchKnowledgeSuspenseQueryHookResult = ReturnType<typeof useSearchKnowledgeSuspenseQuery>;+export type SearchKnowledgeQueryResult = Apollo.QueryResult<SearchKnowledgeQuery, SearchKnowledgeQueryVariables>;export const SettingsUserDocument = gql`query settingsUser {settingsUser {@@ -6261,6 +6673,139 @@ export type DeleteApiTokenMutationOptions = Apollo.BaseMutationOptions<DeleteApiTokenMutation,DeleteApiTokenMutationVariables>;+export const CreateKnowledgeDocumentDocument = gql`+ mutation createKnowledgeDocument($input: CreateKnowledgeDocumentInput!) {+ createKnowledgeDocument(input: $input) {+ ...knowledgeDocumentFragment+ }+ }+ ${KnowledgeDocumentFragmentFragmentDoc}+`;+export type CreateKnowledgeDocumentMutationFn = Apollo.MutationFunction<+ CreateKnowledgeDocumentMutation,+ CreateKnowledgeDocumentMutationVariables+>;++/**+ * __useCreateKnowledgeDocumentMutation__+ *+ * To run a mutation, you first call `useCreateKnowledgeDocumentMutation` within a React component and pass it any options that fit your needs.+ * When your component renders, `useCreateKnowledgeDocumentMutation` returns a tuple that includes:+ * - A mutate function that you can call at any time to execute the mutation+ * - An object with fields that represent the current status of the mutation's execution+ *+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;+ *+ * @example+ * const [createKnowledgeDocumentMutation, { data, loading, error }] = useCreateKnowledgeDocumentMutation({+ * variables: {+ * input: // value for 'input'+ * },+ * });+ */+export function useCreateKnowledgeDocumentMutation(+ baseOptions?: Apollo.MutationHookOptions<CreateKnowledgeDocumentMutation, CreateKnowledgeDocumentMutationVariables>,+) {+ const options = { ...defaultOptions, ...baseOptions };+ return Apollo.useMutation<CreateKnowledgeDocumentMutation, CreateKnowledgeDocumentMutationVariables>(+ CreateKnowledgeDocumentDocument,+ options,+ );+}+export type CreateKnowledgeDocumentMutationHookResult = ReturnType<typeof useCreateKnowledgeDocumentMutation>;+export type CreateKnowledgeDocumentMutationResult = Apollo.MutationResult<CreateKnowledgeDocumentMutation>;+export type CreateKnowledgeDocumentMutationOptions = Apollo.BaseMutationOptions<+ CreateKnowledgeDocumentMutation,+ CreateKnowledgeDocumentMutationVariables+>;+export const UpdateKnowledgeDocumentDocument = gql`+ mutation updateKnowledgeDocument($id: String!, $input: UpdateKnowledgeDocumentInput!) {+ updateKnowledgeDocument(id: $id, input: $input) {+ ...knowledgeDocumentFragment+ }+ }+ ${KnowledgeDocumentFragmentFragmentDoc}+`;+export type UpdateKnowledgeDocumentMutationFn = Apollo.MutationFunction<+ UpdateKnowledgeDocumentMutation,+ UpdateKnowledgeDocumentMutationVariables+>;++/**+ * __useUpdateKnowledgeDocumentMutation__+ *+ * To run a mutation, you first call `useUpdateKnowledgeDocumentMutation` within a React component and pass it any options that fit your needs.+ * When your component renders, `useUpdateKnowledgeDocumentMutation` returns a tuple that includes:+ * - A mutate function that you can call at any time to execute the mutation+ * - An object with fields that represent the current status of the mutation's execution+ *+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;+ *+ * @example+ * const [updateKnowledgeDocumentMutation, { data, loading, error }] = useUpdateKnowledgeDocumentMutation({+ * variables: {+ * id: // value for 'id'+ * input: // value for 'input'+ * },+ * });+ */+export function useUpdateKnowledgeDocumentMutation(+ baseOptions?: Apollo.MutationHookOptions<UpdateKnowledgeDocumentMutation, UpdateKnowledgeDocumentMutationVariables>,+) {+ const options = { ...defaultOptions, ...baseOptions };+ return Apollo.useMutation<UpdateKnowledgeDocumentMutation, UpdateKnowledgeDocumentMutationVariables>(+ UpdateKnowledgeDocumentDocument,+ options,+ );+}+export type UpdateKnowledgeDocumentMutationHookResult = ReturnType<typeof useUpdateKnowledgeDocumentMutation>;+export type UpdateKnowledgeDocumentMutationResult = Apollo.MutationResult<UpdateKnowledgeDocumentMutation>;+export type UpdateKnowledgeDocumentMutationOptions = Apollo.BaseMutationOptions<+ UpdateKnowledgeDocumentMutation,+ UpdateKnowledgeDocumentMutationVariables+>;+export const DeleteKnowledgeDocumentDocument = gql`+ mutation deleteKnowledgeDocument($id: String!) {+ deleteKnowledgeDocument(id: $id)+ }+`;+export type DeleteKnowledgeDocumentMutationFn = Apollo.MutationFunction<+ DeleteKnowledgeDocumentMutation,+ DeleteKnowledgeDocumentMutationVariables+>;++/**+ * __useDeleteKnowledgeDocumentMutation__+ *+ * To run a mutation, you first call `useDeleteKnowledgeDocumentMutation` within a React component and pass it any options that fit your needs.+ * When your component renders, `useDeleteKnowledgeDocumentMutation` returns a tuple that includes:+ * - A mutate function that you can call at any time to execute the mutation+ * - An object with fields that represent the current status of the mutation's execution+ *+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;+ *+ * @example+ * const [deleteKnowledgeDocumentMutation, { data, loading, error }] = useDeleteKnowledgeDocumentMutation({+ * variables: {+ * id: // value for 'id'+ * },+ * });+ */+export function useDeleteKnowledgeDocumentMutation(+ baseOptions?: Apollo.MutationHookOptions<DeleteKnowledgeDocumentMutation, DeleteKnowledgeDocumentMutationVariables>,+) {+ const options = { ...defaultOptions, ...baseOptions };+ return Apollo.useMutation<DeleteKnowledgeDocumentMutation, DeleteKnowledgeDocumentMutationVariables>(+ DeleteKnowledgeDocumentDocument,+ options,+ );+}+export type DeleteKnowledgeDocumentMutationHookResult = ReturnType<typeof useDeleteKnowledgeDocumentMutation>;+export type DeleteKnowledgeDocumentMutationResult = Apollo.MutationResult<DeleteKnowledgeDocumentMutation>;+export type DeleteKnowledgeDocumentMutationOptions = Apollo.BaseMutationOptions<+ DeleteKnowledgeDocumentMutation,+ DeleteKnowledgeDocumentMutationVariables+>;export const TerminalLogAddedDocument = gql`subscription terminalLogAdded($flowId: ID!) {terminalLogAdded(flowId: $flowId) {@@ -7474,3 +8019,120 @@ export function useResourceDeletedSubscription(}export type ResourceDeletedSubscriptionHookResult = ReturnType<typeof useResourceDeletedSubscription>;export type ResourceDeletedSubscriptionResult = Apollo.SubscriptionResult<ResourceDeletedSubscription>;+export const KnowledgeDocumentCreatedDocument = gql`+ subscription knowledgeDocumentCreated {+ knowledgeDocumentCreated {+ ...knowledgeDocumentFragment+ }+ }+ ${KnowledgeDocumentFragmentFragmentDoc}+`;++/**+ * __useKnowledgeDocumentCreatedSubscription__+ *+ * To run a query within a React component, call `useKnowledgeDocumentCreatedSubscription` and pass it any options that fit your needs.+ * When your component renders, `useKnowledgeDocumentCreatedSubscription` returns an object from Apollo Client that contains loading, error, and data properties+ * you can use to render your UI.+ *+ * @param baseOptions options that will be passed into the subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;+ *+ * @example+ * const { data, loading, error } = useKnowledgeDocumentCreatedSubscription({+ * variables: {+ * },+ * });+ */+export function useKnowledgeDocumentCreatedSubscription(+ baseOptions?: Apollo.SubscriptionHookOptions<+ KnowledgeDocumentCreatedSubscription,+ KnowledgeDocumentCreatedSubscriptionVariables+ >,+) {+ const options = { ...defaultOptions, ...baseOptions };+ return Apollo.useSubscription<KnowledgeDocumentCreatedSubscription, KnowledgeDocumentCreatedSubscriptionVariables>(+ KnowledgeDocumentCreatedDocument,+ options,+ );+}+export type KnowledgeDocumentCreatedSubscriptionHookResult = ReturnType<typeof useKnowledgeDocumentCreatedSubscription>;+export type KnowledgeDocumentCreatedSubscriptionResult =+ Apollo.SubscriptionResult<KnowledgeDocumentCreatedSubscription>;+export const KnowledgeDocumentUpdatedDocument = gql`+ subscription knowledgeDocumentUpdated {+ knowledgeDocumentUpdated {+ ...knowledgeDocumentFragment+ }+ }+ ${KnowledgeDocumentFragmentFragmentDoc}+`;++/**+ * __useKnowledgeDocumentUpdatedSubscription__+ *+ * To run a query within a React component, call `useKnowledgeDocumentUpdatedSubscription` and pass it any options that fit your needs.+ * When your component renders, `useKnowledgeDocumentUpdatedSubscription` returns an object from Apollo Client that contains loading, error, and data properties+ * you can use to render your UI.+ *+ * @param baseOptions options that will be passed into the subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;+ *+ * @example+ * const { data, loading, error } = useKnowledgeDocumentUpdatedSubscription({+ * variables: {+ * },+ * });+ */+export function useKnowledgeDocumentUpdatedSubscription(+ baseOptions?: Apollo.SubscriptionHookOptions<+ KnowledgeDocumentUpdatedSubscription,+ KnowledgeDocumentUpdatedSubscriptionVariables+ >,+) {+ const options = { ...defaultOptions, ...baseOptions };+ return Apollo.useSubscription<KnowledgeDocumentUpdatedSubscription, KnowledgeDocumentUpdatedSubscriptionVariables>(+ KnowledgeDocumentUpdatedDocument,+ options,+ );+}+export type KnowledgeDocumentUpdatedSubscriptionHookResult = ReturnType<typeof useKnowledgeDocumentUpdatedSubscription>;+export type KnowledgeDocumentUpdatedSubscriptionResult =+ Apollo.SubscriptionResult<KnowledgeDocumentUpdatedSubscription>;+export const KnowledgeDocumentDeletedDocument = gql`+ subscription knowledgeDocumentDeleted {+ knowledgeDocumentDeleted {+ ...knowledgeDocumentFragment+ }+ }+ ${KnowledgeDocumentFragmentFragmentDoc}+`;++/**+ * __useKnowledgeDocumentDeletedSubscription__+ *+ * To run a query within a React component, call `useKnowledgeDocumentDeletedSubscription` and pass it any options that fit your needs.+ * When your component renders, `useKnowledgeDocumentDeletedSubscription` returns an object from Apollo Client that contains loading, error, and data properties+ * you can use to render your UI.+ *+ * @param baseOptions options that will be passed into the subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;+ *+ * @example+ * const { data, loading, error } = useKnowledgeDocumentDeletedSubscription({+ * variables: {+ * },+ * });+ */+export function useKnowledgeDocumentDeletedSubscription(+ baseOptions?: Apollo.SubscriptionHookOptions<+ KnowledgeDocumentDeletedSubscription,+ KnowledgeDocumentDeletedSubscriptionVariables+ >,+) {+ const options = { ...defaultOptions, ...baseOptions };+ return Apollo.useSubscription<KnowledgeDocumentDeletedSubscription, KnowledgeDocumentDeletedSubscriptionVariables>(+ KnowledgeDocumentDeletedDocument,+ options,+ );+}+export type KnowledgeDocumentDeletedSubscriptionHookResult = ReturnType<typeof useKnowledgeDocumentDeletedSubscription>;+export type KnowledgeDocumentDeletedSubscriptionResult =+ Apollo.SubscriptionResult<KnowledgeDocumentDeletedSubscription>;