baselith-core 1.2.0__tar.gz → 1.3.0__tar.gz

{baselith_core-1.2.0 → baselith_core-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: baselith-core
-Version: 1.2.0
+Version: 1.3.0
 Summary: A Modular Framework for Baselith-Core Orchestration featuring World Models (MCTS), Swarm, and Native MCP.
 Author-email: Gippo <baselith.ai@gmail.com>
 License-Expression: AGPL-3.0-only
@@ -35,9 +35,9 @@ Requires-Dist: ollama<1.0,>=0.6.0
 Requires-Dist: openai<3.0,>=2.2.0
 Requires-Dist: opentelemetry-api>=1.21.0
 Requires-Dist: opentelemetry-exporter-otlp>=1.21.0
-Requires-Dist: opentelemetry-instrumentation-fastapi>=0.42b0
-Requires-Dist: opentelemetry-instrumentation-httpx>=0.42b0
-Requires-Dist: opentelemetry-instrumentation-redis>=0.42b0
+Requires-Dist: opentelemetry-instrumentation-fastapi>=0.64b0
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.64b0
+Requires-Dist: opentelemetry-instrumentation-redis>=0.64b0
 Requires-Dist: opentelemetry-sdk>=1.21.0
 Requires-Dist: opentelemetry-semantic-conventions>=0.42b0
 Requires-Dist: orjson<4.0,>=3.11.7
@@ -61,7 +61,7 @@ Requires-Dist: argcomplete>=3.2.0
 Provides-Extra: browser
 Requires-Dist: playwright>=1.62.0; extra == "browser"
 Provides-Extra: documents
-Requires-Dist: pypdf>=6.21.2; extra == "documents"
+Requires-Dist: pypdf>=6.21.4; extra == "documents"
 Requires-Dist: python-docx<2,>=1.2.0; extra == "documents"
 Requires-Dist: python-pptx<2,>=1.0.2; extra == "documents"
 Requires-Dist: openpyxl==3.1.5; extra == "documents"

{baselith_core-1.2.0 → baselith_core-1.3.0}/baselith/core/_core_version.py

@@ -10,4 +10,4 @@ tree contains. The system update notice compares ``CORE_VERSION`` (never the
 distribution version) with the public core's releases and security advisories.
 """
 
-CORE_VERSION = "1.2.0"
+CORE_VERSION = "1.3.0"

{baselith_core-1.2.0 → baselith_core-1.3.0}/baselith/core/_version.py

@@ -1,3 +1,3 @@
 """Single source of truth for the framework version."""
 
-__version__ = "1.2.0"
+__version__ = "1.3.0"

{baselith_core-1.2.0 → baselith_core-1.3.0}/baselith/core/api/_runtime_services.py

@@ -23,6 +23,9 @@ Current services:
   of its release mirrors are reported.
 * **Update boot report** (``UPDATE_APPLY_ENABLED``) — each worker records the
   plugins it loaded so the one-click updater can verify a restart.
+* **Workflows** (``WORKFLOWS_ENABLED``) - the workflow catalog, its cron
+  scheduler and the MCP tools of exposed workflows
+  (:class:`baselith.core.workflows.service.WorkflowService`).
 * **Online evaluation** (``EVAL_ENABLED`` + ``EVAL_ONLINE_ENABLED``) — the
   sampled evaluation of production flows
   (:class:`baselith.core.evaluation.EvaluationService`), started through the
@@ -96,6 +99,7 @@ async def start_runtime_services(app: Any) -> None:
 
     await _start_webhook_outbox(app)
     await _start_online_evaluation(app)
+    await _start_workflows(app)
     await _write_update_boot_report()
 
 
@@ -115,6 +119,16 @@ async def _start_webhook_outbox(app: Any) -> None:
         logger.warning("webhook_outbox_start_failed: %s", exc)
 
 
+async def _start_workflows(app: Any) -> None:
+    """Start the workflow catalog, scheduler and MCP sync when enabled."""
+    try:
+        from baselith.core.workflows.service import start_workflow_service
+
+        await start_workflow_service(app)
+    except Exception as exc:
+        logger.warning("workflow_service_start_failed: %s", exc)
+
+
 async def _start_online_evaluation(app: Any) -> None:
     """Start online evaluation when both evaluation switches are on."""
     try:
@@ -199,6 +213,13 @@ async def stop_runtime_services(app: Any) -> None:
         except Exception as exc:
             logger.warning("evaluation_service_stop_failed: %s", exc)
 
+    try:
+        from baselith.core.workflows.service import stop_workflow_service
+
+        await stop_workflow_service(app)
+    except Exception as exc:
+        logger.warning("workflow_service_stop_failed: %s", exc)
+
     plugin_updates = getattr(app.state, "plugin_updates", None)
     if plugin_updates is not None:
         try:

{baselith_core-1.2.0 → baselith_core-1.3.0}/baselith/core/api/lifespan.py

@@ -6,6 +6,7 @@ resource initialization, plugin loading, and rate limiter setup.
 """
 
 import asyncio
+import gc
 import os
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
@@ -419,9 +420,23 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
 
     await start_runtime_services(app)
 
+    # Take the startup heap off the collector's books. Everything built above
+    # — the app and its routers, the plugin registries, the config
+    # singletons, the pools — lives until shutdown, yet every full collection
+    # re-walked it: on the built app that is ~140k tracked objects and a
+    # 16ms gen-2 pause, 0ms once frozen. Request-time garbage is still
+    # collected as before; what the pass no longer traverses is the part
+    # that was never garbage. The collect first drops the garbage startup
+    # itself left behind, so the permanent generation holds only what lives.
+    # Undone at shutdown, so a process that runs several lifespans (tests)
+    # is not left with a permanent generation it never asked for.
+    gc.collect()
+    gc.freeze()
+
     try:
         yield
     finally:
+        gc.unfreeze()
         # Ordered, isolated teardown: one failing step no longer skips the
         # pool drains and the telemetry flush after it (baselith.core.api._shutdown).
         from baselith.core.api._shutdown import shutdown_application

{baselith_core-1.2.0 → baselith_core-1.3.0}/baselith/core/auth/scopes.py

@@ -46,6 +46,8 @@ SCOPE_MEMORY_READ = "memory:read"
 SCOPE_MEMORY_WRITE = "memory:write"
 SCOPE_FEEDBACK_WRITE = "feedback:write"
 SCOPE_METRICS_READ = "metrics:read"
+SCOPE_KNOWLEDGE_READ = "knowledge:read"
+SCOPE_KNOWLEDGE_WRITE = "knowledge:write"
 SCOPE_WEBHOOKS_READ = "webhooks:read"
 SCOPE_WEBHOOKS_WRITE = "webhooks:write"
 SCOPE_KEYS_MANAGE = "keys:manage"
@@ -71,6 +73,8 @@ KNOWN_SCOPES: frozenset[str] = frozenset(
         SCOPE_MEMORY_READ,
         SCOPE_MEMORY_WRITE,
         SCOPE_FEEDBACK_WRITE,
+        SCOPE_KNOWLEDGE_READ,
+        SCOPE_KNOWLEDGE_WRITE,
         SCOPE_METRICS_READ,
         SCOPE_WEBHOOKS_READ,
         SCOPE_WEBHOOKS_WRITE,
@@ -100,6 +104,7 @@ ROLE_SCOPES: dict[AuthRole, frozenset[str]] = {
             "chat:*",
             "memory:*",
             "feedback:*",
+            "knowledge:*",
             "webhooks:*",
             SCOPE_METRICS_READ,
             SCOPE_MCP_INVOKE,
@@ -113,6 +118,7 @@ ROLE_SCOPES: dict[AuthRole, frozenset[str]] = {
             SCOPE_MEMORY_READ,
             SCOPE_MEMORY_WRITE,
             SCOPE_FEEDBACK_WRITE,
+            SCOPE_KNOWLEDGE_READ,
             SCOPE_METRICS_READ,
             SCOPE_MCP_INVOKE,
         }
@@ -124,6 +130,7 @@ ROLE_SCOPES: dict[AuthRole, frozenset[str]] = {
             SCOPE_CHAT_READ,
             SCOPE_CHAT_WRITE,
             SCOPE_MEMORY_READ,
+            SCOPE_KNOWLEDGE_READ,
             SCOPE_METRICS_READ,
             SCOPE_MCP_INVOKE,
         }

{baselith_core-1.2.0 → baselith_core-1.3.0}/baselith/core/cli/__main__.py

@@ -34,6 +34,7 @@ from baselith.core.cli.handlers import (
     cmd_test,
     cmd_up,
     cmd_verify,
+    cmd_workflow,
     run_command,
 )
 
@@ -67,7 +68,7 @@ except ImportError:
 
 COMMANDS_MAP = {
     "SCAFFOLDING": ["init", "setup", "plugin"],
-    "DEVELOPMENT": ["run", "up", "shell", "docs"],
+    "DEVELOPMENT": ["run", "up", "shell", "docs", "workflow"],
     "SYSTEM & HEALTH": ["doctor", "verify", "info", "config"],
     "INFRASTRUCTURE": ["db", "cache", "queue", "plugin-updater"],
     "QUALITY & TESTS": ["test", "lint"],
@@ -90,6 +91,7 @@ COMMAND_HANDLERS_MAP: dict[str, Any] = {
     "cache": lambda *args, **kwargs: cmd_cache(*args, **kwargs),
     "queue": lambda *args, **kwargs: cmd_queue(*args, **kwargs),
     "plugin-updater": lambda *args, **kwargs: cmd_plugin_updater(*args, **kwargs),
+    "workflow": lambda *args, **kwargs: cmd_workflow(*args, **kwargs),
     "docs": lambda *args, **kwargs: cmd_docs(*args, **kwargs),
     "doctor": lambda *args, **kwargs: cmd_doctor(*args, **kwargs),
     "test": lambda *args, **kwargs: cmd_test(*args, **kwargs),

{baselith_core-1.2.0 → baselith_core-1.3.0}/baselith/core/cli/commands/__init__.py

@@ -18,4 +18,5 @@ __all__ = [
     "shell",
     "test",
     "verify",
+    "workflow",
 ]

baselith_core-1.3.0/baselith/core/cli/commands/workflow.py

@@ -0,0 +1,383 @@
+"""
+Workflow commands: validate, run, export, list and draft definitions, and work
+with the signed inbound trigger.
+
+Definitions are YAML or JSON files; see the Workflow Engine page of the docs.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+from baselith.core.cli.ui import (
+    console,
+    print_error,
+    print_results_table,
+    print_success,
+    print_warning,
+)
+
+
+def _emit(payload: dict[str, Any]) -> None:
+    print(json.dumps(payload, indent=2, default=str))
+
+
+def _load(path: str) -> Any:
+    from baselith.core.workflows.serialization import (
+        DefinitionError,
+        load_definition_file,
+    )
+
+    try:
+        return load_definition_file(path), None
+    except (DefinitionError, OSError) as exc:
+        return None, str(exc)
+
+
+def _parse_input(options: dict[str, Any]) -> Any:
+    """``--input`` / ``--input-file`` as JSON when it parses, else as text."""
+    raw: str | None
+    if options.get("input_file"):
+        raw = Path(options["input_file"]).read_text(encoding="utf-8")
+    else:
+        raw = options.get("input")
+    if raw is None:
+        return None
+    try:
+        return json.loads(raw)
+    except ValueError:
+        return raw
+
+
+def _validate(options: dict[str, Any], json_output: bool) -> int:
+    results = []
+    for path in options["files"]:
+        workflow, load_error = _load(path)
+        errors = [load_error] if load_error else workflow.validate()
+        results.append({"file": path, "valid": not errors, "errors": errors})
+    if json_output:
+        _emit({"results": results})
+    else:
+        for item in results:
+            if item["valid"]:
+                print_success(f"{item['file']}: valid")
+            else:
+                print_error(f"{item['file']}: invalid")
+                for error in item["errors"]:
+                    console.print(f"  - {error}")
+    return 0 if all(r["valid"] for r in results) else 1
+
+
+def _run(options: dict[str, Any], json_output: bool) -> int:
+    from baselith.core.workflows.runtime import default_executor_factory
+
+    workflow, load_error = _load(options["file"])
+    errors = [load_error] if load_error else workflow.validate()
+    if errors:
+        print_error(f"{options['file']}: invalid", "; ".join(errors))
+        return 1
+    try:
+        payload = _parse_input(options)
+    except OSError as exc:
+        print_error("Could not read the input", str(exc))
+        return 1
+
+    started = time.perf_counter()
+    try:
+        result = asyncio.run(default_executor_factory()().execute(workflow, payload))
+    except Exception as exc:
+        # A HUMAN gate raises here: a one-shot CLI run has no checkpoint store
+        # to pause into, so it fails closed instead of waving the gate through.
+        print_error("Run did not complete", f"{type(exc).__name__}: {exc}")
+        return 1
+    elapsed_ms = (time.perf_counter() - started) * 1000
+    ok = result.status.value == "completed"
+    if json_output:
+        _emit(
+            {
+                "status": result.status.value,
+                "output": result.output,
+                "error": result.error,
+                "duration_ms": round(elapsed_ms, 1),
+            }
+        )
+    elif ok:
+        print(
+            result.output
+            if isinstance(result.output, str)
+            else json.dumps(result.output, indent=2, default=str)
+        )
+    else:
+        print_error("Run failed", result.error)
+    return 0 if ok else 1
+
+
+def _export(options: dict[str, Any], json_output: bool) -> int:
+    from baselith.core.workflows.serialization import DefinitionError, dump_yaml
+
+    workflow, load_error = _load(options["file"])
+    if load_error:
+        print_error(f"{options['file']}: unreadable", load_error)
+        return 1
+    try:
+        text = dump_yaml(workflow) if options["to"] == "yaml" else workflow.to_json()
+    except (DefinitionError, TypeError) as exc:
+        print_error("Cannot export", str(exc))
+        return 1
+    if options.get("output"):
+        Path(options["output"]).write_text(text, encoding="utf-8")
+        print_success(f"Wrote {options['output']}")
+    else:
+        sys.stdout.write(text if text.endswith("\n") else text + "\n")
+    return 0
+
+
+def _catalog(options: dict[str, Any]) -> Any:
+    from baselith.core.config.workflows import get_workflows_config
+    from baselith.core.workflows.catalog import WorkflowCatalog
+
+    directory = options.get("dir") or get_workflows_config().directory
+    return WorkflowCatalog(directory) if directory else None
+
+
+def _list(options: dict[str, Any], json_output: bool) -> int:
+    catalog = _catalog(options)
+    if catalog is None:
+        print_error("No directory", "Pass --dir or set WORKFLOWS_DIR.")
+        return 1
+    report = catalog.load_directory()
+    rows = [
+        {
+            "id": w.id,
+            "name": w.name,
+            "nodes": str(len(w.nodes)),
+            "schedule": w.schedule or "-",
+            "trigger": "yes" if w.webhook_trigger else "-",
+        }
+        for w in catalog.list()
+    ]
+    if json_output:
+        _emit({"workflows": rows, "failed": report.failed})
+    else:
+        if rows:
+            print_results_table(
+                rows,
+                [
+                    {"key": "id", "header": "ID", "style": "cyan"},
+                    {"key": "name", "header": "Name"},
+                    {"key": "nodes", "header": "Nodes", "justify": "right"},
+                    {"key": "schedule", "header": "Schedule"},
+                    {"key": "trigger", "header": "Trigger"},
+                ],
+                title=f"Workflows in {catalog.directory}",
+            )
+        else:
+            print_warning(f"No workflow definitions in {catalog.directory}")
+        for name, reason in report.failed.items():
+            print_error(f"{name}: rejected", reason)
+    return 1 if report.failed else 0
+
+
+def _master() -> str | None:
+    from baselith.core.config.workflows import get_workflows_config
+
+    secret = get_workflows_config().trigger_secret
+    value = secret.get_secret_value() if secret else ""
+    return value or None
+
+
+def _trigger_secret(options: dict[str, Any], json_output: bool) -> int:
+    from baselith.core.workflows.triggers import derive_workflow_secret
+
+    master = _master()
+    if master is None:
+        print_error("WORKFLOWS_TRIGGER_SECRET is not set")
+        return 1
+    key = derive_workflow_secret(master, options["workflow_id"])
+    if json_output:
+        _emit({"workflow_id": options["workflow_id"], "secret": key})
+    else:
+        print(
+            key
+        )  # bare, so it can be captured: KEY=$(baselith workflow trigger-secret ID)
+    return 0
+
+
+def _trigger_sign(options: dict[str, Any], json_output: bool) -> int:
+    from baselith.core.webhooks.signing import SIGNATURE_HEADER, build_signature_header
+    from baselith.core.workflows.triggers import derive_workflow_secret
+
+    master = _master()
+    if master is None:
+        print_error("WORKFLOWS_TRIGGER_SECRET is not set")
+        return 1
+    try:
+        body = (
+            Path(options["body_file"]).read_bytes()
+            if options.get("body_file")
+            else sys.stdin.buffer.read()
+        )
+    except OSError as exc:
+        print_error("Could not read the body", str(exc))
+        return 1
+    header = build_signature_header(
+        derive_workflow_secret(master, options["workflow_id"]), body
+    )
+    if json_output:
+        _emit({"header": SIGNATURE_HEADER, "value": header})
+    else:
+        print(f"{SIGNATURE_HEADER}: {header}")
+    return 0
+
+
+def _generate(options: dict[str, Any], json_output: bool) -> int:
+    from baselith.core.workflows.generator import GenerationError, generate_workflow
+
+    existing = None
+    if options.get("revise"):
+        existing, load_error = _load(options["revise"])
+        if load_error:
+            print_error(f"{options['revise']}: unreadable", load_error)
+            return 1
+    try:
+        result = asyncio.run(
+            generate_workflow(
+                options["description"],
+                existing=existing,
+                max_attempts=options.get("attempts") or 3,
+            )
+        )
+    except GenerationError as exc:
+        print_error("No valid workflow after the allowed attempts")
+        for error in exc.errors[:10]:
+            console.print(f"  - {error}")
+        return 1
+    except Exception as exc:
+        print_error("Generation failed", f"{type(exc).__name__}: {exc}")
+        return 1
+    if not json_output:
+        # stderr, so `baselith workflow generate ... > w.yaml` stays valid YAML.
+        for warning in result.warnings:
+            print(f"warning: {warning}", file=sys.stderr)
+    if options.get("output"):
+        Path(options["output"]).write_text(result.yaml, encoding="utf-8")
+        if not json_output:
+            print_success(f"Wrote {options['output']} ({result.attempts} attempt(s))")
+    elif not json_output:
+        sys.stdout.write(result.yaml)
+    if json_output:
+        _emit(
+            {
+                "attempts": result.attempts,
+                "warnings": result.warnings,
+                "workflow": result.definition.to_dict(),
+            }
+        )
+    return 0
+
+
+_COMMANDS = {
+    "generate": _generate,
+    "validate": _validate,
+    "run": _run,
+    "export": _export,
+    "list": _list,
+    "trigger-secret": _trigger_secret,
+    "trigger-sign": _trigger_sign,
+}
+
+
+def run_workflow(
+    command: str, options: dict[str, Any], *, json_output: bool = False
+) -> int:
+    """Dispatch a ``baselith workflow`` subcommand; returns the exit code."""
+    handler = _COMMANDS.get(command)
+    if handler is None:
+        print_error("Unknown workflow command", command)
+        return 1
+    return handler(options, json_output)
+
+
+def register_parser(
+    subparsers: argparse._SubParsersAction[argparse.ArgumentParser],
+    formatter_class: type[argparse.HelpFormatter],
+) -> argparse.ArgumentParser:
+    """Register the 'workflow' command parser."""
+    parser = subparsers.add_parser(
+        "workflow",
+        help="Validate, run and manage workflow definitions",
+        description="Work with workflow definitions (YAML or JSON): check them, "
+        "run them once, convert them, list a catalog directory, and handle the "
+        "signing key of the inbound trigger.",
+        formatter_class=formatter_class,
+    )
+    sub = parser.add_subparsers(dest="workflow_command", title="Workflow Operations")
+
+    validate = sub.add_parser(
+        "validate",
+        help="Check one or more definition files",
+        formatter_class=formatter_class,
+    )
+    validate.add_argument("files", nargs="+", metavar="FILE")
+
+    run = sub.add_parser(
+        "run",
+        help="Run a definition once with the configured services",
+        formatter_class=formatter_class,
+    )
+    run.add_argument("file", metavar="FILE")
+    run.add_argument("--input", help="Initial input (JSON if it parses, else text)")
+    run.add_argument("--input-file", help="Read the initial input from a file")
+
+    export = sub.add_parser(
+        "export",
+        help="Convert a definition between YAML and JSON",
+        formatter_class=formatter_class,
+    )
+    export.add_argument("file", metavar="FILE")
+    export.add_argument("--to", choices=["yaml", "json"], default="yaml")
+    export.add_argument("-o", "--output", help="Write to a file instead of stdout")
+
+    listing = sub.add_parser(
+        "list",
+        help="List the definitions in a catalog directory",
+        formatter_class=formatter_class,
+    )
+    listing.add_argument("--dir", help="Directory (default: WORKFLOWS_DIR)")
+
+    generate = sub.add_parser(
+        "generate",
+        help="Draft a definition from a description, checked before it is shown",
+        formatter_class=formatter_class,
+    )
+    generate.add_argument("description", help="What the workflow should do (or change)")
+    generate.add_argument(
+        "--revise", metavar="FILE", help="Revise this definition instead"
+    )
+    generate.add_argument("--attempts", type=int, choices=range(1, 6), metavar="1-5")
+    generate.add_argument("-o", "--output", help="Write the YAML to a file")
+
+    secret = sub.add_parser(
+        "trigger-secret",
+        help="Print the signing key of one workflow's inbound trigger",
+        formatter_class=formatter_class,
+    )
+    secret.add_argument("workflow_id", metavar="ID")
+
+    sign = sub.add_parser(
+        "trigger-sign",
+        help="Print the X-Baselith-Signature header for a request body",
+        formatter_class=formatter_class,
+    )
+    sign.add_argument("workflow_id", metavar="ID")
+    sign.add_argument("--body-file", help="File holding the body (default: stdin)")
+    return parser
+
+
+__all__ = ["register_parser", "run_workflow"]

{baselith_core-1.2.0 → baselith_core-1.3.0}/baselith/core/cli/handlers.py

@@ -282,6 +282,19 @@ def cmd_cache(args: argparse.Namespace) -> int:
     )
 
 
+def cmd_workflow(args: argparse.Namespace) -> int:
+    """Execute the 'workflow' command (validate, run, export, list, triggers)."""
+    from baselith.core.cli.commands.workflow import run_workflow
+
+    command = getattr(args, "workflow_command", None)
+    if command is None:
+        print(
+            "usage: baselith workflow {validate,run,export,list,generate,trigger-secret,trigger-sign} ..."
+        )
+        return 1
+    return run_workflow(command, vars(args), json_output=_wants_json(args))
+
+
 def cmd_queue(args: argparse.Namespace) -> int:
     """Execute the 'queue' command for task queue management."""
     from baselith.core.cli.commands.queue import run_queue
@@ -359,6 +372,7 @@ COMMAND_HANDLERS_MAP = {
     "db": cmd_db,
     "cache": cmd_cache,
     "queue": cmd_queue,
+    "workflow": cmd_workflow,
     "plugin-updater": cmd_plugin_updater,
     "docs": cmd_docs,
     "doctor": cmd_doctor,

{baselith_core-1.2.0 → baselith_core-1.3.0}/baselith/core/config/__init__.py

@@ -34,6 +34,7 @@ from baselith.core.config.drift import (
 from baselith.core.config.environment import get_runtime_environment, is_production_env
 from baselith.core.config.evaluation import EvaluationConfig, evaluation_config
 from baselith.core.config.events import EventsConfig, get_events_config
+from baselith.core.config.knowledge import KnowledgeApiConfig, get_knowledge_config
 from baselith.core.config.mcp import MCPConfig, MCPServerSpec, get_mcp_config
 from baselith.core.config.memory import (
     MemoryRuntimeConfig,
@@ -87,6 +88,7 @@ from baselith.core.config.swarm import (
 )
 from baselith.core.config.task_queue import TaskQueueConfig
 from baselith.core.config.webhooks import WebhookConfig, get_webhook_config
+from baselith.core.config.workflows import WorkflowsConfig, get_workflows_config
 from baselith.core.config.world_model import WorldModelConfig, get_world_model_config
 
 __all__ = [
@@ -127,6 +129,8 @@ __all__ = [
     "VisionConfig",
     "VoiceConfig",
     "WebhookConfig",
+    "KnowledgeApiConfig",
+    "WorkflowsConfig",
     "WorldModelConfig",
     "evaluation_config",
     "get_app_config",
@@ -164,6 +168,8 @@ __all__ = [
     "get_vision_config",
     "get_voice_config",
     "get_webhook_config",
+    "get_knowledge_config",
+    "get_workflows_config",
     "get_world_model_config",
     "is_production_env",
 ]