Skip to content

Fully autonomous AI Agents system capable of performing complex penetration testing tasks

feat(knowledge): add pgvector knowledge base management

Dmitry Ng3a5207927856
diff --git a/backend/cmd/ftester/mocks/logs.go b/backend/cmd/ftester/mocks/logs.go
index d3cd0c52..71b75385 100644
--- a/backend/cmd/ftester/mocks/logs.go
+++ b/backend/cmd/ftester/mocks/logs.go
@@ -3,8 +3,10 @@ package mocks
import (
"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.SearchLogProvider
GetTermLogProvider() tools.TermLogProvider
GetVectorStoreLogProvider() tools.VectorStoreLogProvider
+ GetKnowledgeProvider() tools.KnowledgeProvider
}
// proxyProviders contains all the proxy implementations for various providers
type 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 providers
func 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.VectorStoreLogProvide
return p.vectorStoreLog
}
+func (p *proxyProviders) GetKnowledgeProvider() tools.KnowledgeProvider {
+ return p.knowledgeProvider
+}
+
// proxyScreenshotProvider is a proxy implementation of ScreenshotProvider
type 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.go
index 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.Store
graphitiClient *graphiti.Client
proxies mocks.ProxyProviders
+ userID int64
flowID int64
taskID *int64
subtaskID *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.Too
case tools.SearchGuideToolName:
return tools.NewGuideTool(
+ te.userID,
te.flowID,
te.taskID,
te.subtaskID,
te.replacer,
te.store,
te.proxies.GetVectorStoreLogProvider(),
+ te.proxies.GetKnowledgeProvider(),
), nil
case tools.SearchAnswerToolName:
return tools.NewSearchTool(
+ te.userID,
te.flowID,
te.taskID,
te.subtaskID,
te.replacer,
te.store,
te.proxies.GetVectorStoreLogProvider(),
+ te.proxies.GetKnowledgeProvider(),
), nil
case tools.SearchCodeToolName:
return tools.NewCodeTool(
+ te.userID,
te.flowID,
te.taskID,
te.subtaskID,
te.replacer,
te.store,
te.proxies.GetVectorStoreLogProvider(),
+ te.proxies.GetKnowledgeProvider(),
), nil
case tools.GraphitiSearchToolName:
diff --git a/backend/cmd/ftester/worker/tester.go b/backend/cmd/ftester/worker/tester.go
index 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 executor
toolExecutor, 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.mod
index 5394abd1..4a31f836 100644
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -45,6 +45,7 @@ require (
github.com/rivo/uniseg v0.4.7
github.com/shirou/gopsutil/v3 v3.24.5
github.com/sirupsen/logrus v1.9.3
+ github.com/sqlc-dev/pqtype v0.3.0
github.com/stretchr/testify v1.11.1
github.com/swaggo/gin-swagger v1.3.0
github.com/swaggo/swag v1.8.7
diff --git a/backend/go.sum b/backend/go.sum
index 402f4193..ee265fa3 100644
--- a/backend/go.sum
+++ b/backend/go.sum
@@ -555,6 +555,8 @@ github.com/sosodev/duration v1.3.1 h1:qtHBDMQ6lvMQsL15g4aopM4HEfOaYuhWBw3NPTtlqq
github.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.sql
new file mode 100644
index 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 StatementEnd
diff --git a/backend/pkg/controller/assistant.go b/backend/pkg/controller/assistant.go
index 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) (Assista
executor.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 int64
pmsgChainID := database.NullInt64ToInt64(assistant.MsgchainID)
diff --git a/backend/pkg/controller/flow.go b/backend/pkg/controller/flow.go
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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 = &gt
+ }
+ 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.go
new file mode 100644
index 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.go
index 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.go
index 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) error
DeleteFlowTemplate(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) error
DeletePrompt(ctx context.Context, id int64) error
DeleteProvider(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) error
DeleteUserAPIToken(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) error
DeleteUserPreferences(ctx context.Context, userID int64) error
DeleteUserPrompt(ctx context.Context, arg DeleteUserPromptParams) error
DeleteUserProvider(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 week
GetFlowsStatsByDayLastWeek(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.go
index 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) int
FlowID 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) int
FlowsStatsByPeriod func(childComplexity int, period model.UsageStatsPeriod) int
FlowsStatsTotal func(childComplexity int) int
+ KnowledgeDocument func(childComplexity int, id string) int
+ KnowledgeDocuments func(childComplexity int, filter *model.KnowledgeFilter, withContent bool) int
MessageLogs func(childComplexity int, flowID int64) int
Providers func(childComplexity int) int
Resources func(childComplexity int, path *string, recursive *bool) int
Screenshots func(childComplexity int, flowID int64) int
+ SearchKnowledge func(childComplexity int, query string, filter *model.KnowledgeFilter, limit *int) int
SearchLogs func(childComplexity int, flowID int64) int
Settings func(childComplexity int) int
SettingsPrompts 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 in
return 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 in
return 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 in
return 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 in
return 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 in
return 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 in
return 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 in
return 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 error
args := 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 error
args := 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 error
args := 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 error
args := 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"] = arg0
return 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 string
return 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 string
return 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 error
args := 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"] = arg1
return 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.KnowledgeFilter
return 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.KnowledgeFilter
return 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 bool
return 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 bool
return 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 error
args := 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"] = arg0
return 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 error
args := 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"] = arg1
return 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 *string
return 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 *string
return 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 error
args := 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"] = arg0
return 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 error
args := 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"] = arg2
return 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 string
return 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 string
return 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 *int
return 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 *int
return 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 error
args := 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"] = arg0
return 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_argsFlow
return 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 error
args := 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"] = arg0
return 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 int64
return 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 int64
return 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 error
args := 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"] = arg0
return 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 error
args := 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"] = arg0
return 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 error
args := 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"] = arg0
return 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_argsFlowI
return 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 error
args := 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"] = arg0
return 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 error
args := 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"] = arg0
return 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 error
args := 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"] = arg0
return 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 error
args := 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"] = arg0
return 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 error
args := 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"] = arg0
return 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.UsageStatsPeriod
return 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.UsageStatsPeriod
return 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 error
args := 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"] = arg0
return 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 error
args := 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"] = arg0
return 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 error
args := 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"] = arg0
return 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 error
args := 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"] = arg0
return 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 error
args := 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"] = arg0
return 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 grap
return 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(_ context
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)
+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.Context
return 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(_ conte
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)
+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(_ contex
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)
+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 con
return 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_totalDurationSec
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)
+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 context
return 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, fi
return 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, f
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)
+ 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, f
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)
+ 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, f
w.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, f
w.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.Contex
w.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(_ cont
Child: 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(_ cont
return 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.Contex
w.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(_ cont
Child: 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.Contex
w.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(_ cont
Child: 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.Co
return 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, f
w.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, f
w.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.Co
return 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.ModelPrice
asMap := map[string]interface{}{}
@@ -33067,6 +35247,68 @@ func (ec *executionContext) unmarshalInputUpdateFlowTemplateInput(ctx context.Co
return 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.SelectionSe
return 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) gr
func(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.Selection
return 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ᚋgr
return 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.Selecti
return 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ᚋgr
return 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.Sele
return 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ᚋmode
return 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, nil
diff --git a/backend/pkg/graph/model/models_gen.go b/backend/pkg/graph/model/models_gen.go
index 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 string
const (
diff --git a/backend/pkg/graph/resolver.go b/backend/pkg/graph/resolver.go
index 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.ProviderController
Controller controller.FlowController
Subscriptions subscriptions.SubscriptionsController
+ Knowledge knowledge.KnowledgeStore
}
diff --git a/backend/pkg/graph/schema.graphqls b/backend/pkg/graph/schema.graphqls
index 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 management
resources(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.go
index 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 in
return 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 *mod
return 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.go
index 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) SettingsPublisher
NewFlowTemplateSubscriber(userID int64) FlowTemplateSubscriber
NewFlowTemplatePublisher(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)
FlowContext
UserContext
}
+// 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) FlowTemplateSubscri
return &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 T
Publish(ctx context.Context, id int64, data T)
diff --git a/backend/pkg/graph/subscriptions/publisher.go b/backend/pkg/graph/subscriptions/publisher.go
index 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 da
p.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 *model
p.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.go
index 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.go
index 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.json
index 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.yaml
index ddbcf48a..7e2cf2b6 100644
--- a/backend/pkg/server/docs/swagger.yaml
+++ b/backend/pkg/server/docs/swagger.yaml
@@ -510,6 +510,33 @@ definitions:
- input
- provider
type: 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: object
models.DailyFlowsStats:
properties:
date:
@@ -758,6 +785,97 @@ definitions:
required:
- function_name
type: 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: object
models.Login:
properties:
mail:
@@ -1308,6 +1426,29 @@ definitions:
status:
type: string
type: 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: object
models.UsageStats:
properties:
total_usage_cache_in:
@@ -4494,6 +4635,301 @@ paths:
summary: Retrieve current user and system settings
tags:
- 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.go
new file mode 100644
index 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 = &gt
+ }
+ 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 = &gt
+ }
+ 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 = &gt
+ }
+ 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 = &gt
+ }
+ 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.go
index 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", "r
var 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")
+
// tokens
var 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.go
index 082d9d79..e84c4f51 100644
--- a/backend/pkg/server/router.go
+++ b/backend/pkg/server/router.go
@@ -1,6 +1,7 @@
package router
import (
+ "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)
+
// services
authService := 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.go
index 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) subscrip
func (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, _ database
func (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 referenced
diff --git a/backend/pkg/server/services/flows.go b/backend/pkg/server/services/flows.go
index 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.go
index 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.go
new file mode 100644
index 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.go
index 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.Flo
func (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 1
wantResponsePaths: []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.go
index 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 int64
flowID int64
taskID *int64
subtaskID *int64
replacer anonymizer.Replacer
store *pgvector.Store
vslp 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) (s
if doc.Metadata == nil {
doc.Metadata = map[string]any{}
}
+ doc.Metadata["user_id"] = c.userID
doc.Metadata["flow_id"] = c.flowID
if 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) (s
doc.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) (s
langfuse.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.go
index 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 int64
flowID int64
taskID *int64
subtaskID *int64
@@ -563,13 +564,14 @@ func (ce *customExecutor) storeToolResult(ctx context.Context, name, result stri
if doc.Metadata == nil {
doc.Metadata = map[string]any{}
}
+ doc.Metadata["user_id"] = ce.userID
+ doc.Metadata["flow_id"] = ce.flowID
if ce.taskID != nil {
doc.Metadata["task_id"] = *ce.taskID
}
if ce.subtaskID != nil {
doc.Metadata["subtask_id"] = *ce.subtaskID
}
- doc.Metadata["flow_id"] = ce.flowID
doc.Metadata["tool_name"] = name
if def, ok := registryDefinitions[name]; ok {
doc.Metadata["tool_description"] = def.Description
diff --git a/backend/pkg/tools/guide.go b/backend/pkg/tools/guide.go
index 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 int64
flowID int64
taskID *int64
subtaskID *int64
replacer anonymizer.Replacer
store *pgvector.Store
vslp 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.userID
doc.Metadata["flow_id"] = g.flowID
if 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.go
index 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 int64
flowID int64
taskID *int64
subtaskID *int64
replacer anonymizer.Replacer
store *pgvector.Store
vslp 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.userID
doc.Metadata["flow_id"] = s.flowID
doc.Metadata["task_id"] = s.taskID
doc.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.go
index 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 int64
flowID int64
scp ScreenshotProvider
alp AgentLogProvider
@@ -148,6 +154,7 @@ type flowToolsExecutor struct {
slp SearchLogProvider
tlp TermLogProvider
vslp VectorStoreLogProvider
+ knp KnowledgeProvider
db database.Querier
cfg *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 VectorStoreLogProvi
fte.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.sql
new file mode 100644
index 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.yml
index 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 analysis
database:
diff --git a/frontend/graphql-schema.graphql b/frontend/graphql-schema.graphql
index 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 {
id
favoriteFlows
@@ -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.ts
index 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]: never
export 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>;