claude-smart 0.2.42 → 0.2.44

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/types/openclaw.d.ts

@@ -0,0 +1,230 @@
+// Narrow ambient shim for the Openclaw Plugin SDK surface that this plugin
+// actually touches. The real types ship with the `openclaw` npm package, but
+// we avoid depending on the full host at build time — plugins load at runtime
+// via the host's own jiti instance.
+//
+// If you need richer type coverage, install `openclaw` as a devDependency and
+// delete this file; the real .d.ts files will take over.
+declare module "openclaw/plugin-sdk/plugin-entry" {
+  export type PluginHookName =
+    | "before_model_resolve"
+    | "before_prompt_build"
+    | "before_agent_start"
+    | "before_agent_reply"
+    | "llm_input"
+    | "llm_output"
+    | "agent_end"
+    | "before_compaction"
+    | "after_compaction"
+    | "before_reset"
+    | "inbound_claim"
+    | "message_received"
+    | "message_sending"
+    | "message_sent"
+    | "before_tool_call"
+    | "after_tool_call"
+    | "tool_result_persist"
+    | "before_message_write"
+    | "session_start"
+    | "session_end"
+    | "subagent_spawning"
+    | "subagent_delivery_target"
+    | "subagent_spawned"
+    | "subagent_ended"
+    | "gateway_start"
+    | "gateway_stop"
+    | "before_dispatch"
+    | "reply_dispatch"
+    | "before_install";
+
+  export type PluginLogger = {
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+    error?: (msg: string) => void;
+    debug?: (msg: string) => void;
+  };
+
+  export type PluginRuntime = {
+    subagent?: {
+      run: (params: {
+        sessionKey: string;
+        message: string;
+        provider?: string;
+        model?: string;
+        extraSystemPrompt?: string;
+        lane?: string;
+        deliver?: boolean;
+        idempotencyKey?: string;
+      }) => Promise<{ runId: string }>;
+    };
+    system: {
+      runCommandWithTimeout: (
+        argv: string[],
+        opts: { timeoutMs: number; input?: string },
+      ) => Promise<{ stdout: string; stderr: string; code: number | null }>;
+    };
+    config: {
+      loadConfig: () => unknown;
+    };
+  };
+
+  export type PluginHookAgentContext = {
+    runId?: string;
+    agentId?: string;
+    sessionKey?: string;
+    sessionId?: string;
+    workspaceDir?: string;
+  };
+
+  export type PluginHookSessionContext = {
+    agentId?: string;
+    sessionId: string;
+    sessionKey?: string;
+    workspaceDir?: string;
+  };
+
+  export type PluginHookBeforeAgentStartEvent = {
+    prompt: string;
+    messages?: unknown[];
+  };
+
+  export type PluginHookBeforeAgentStartResult = {
+    prependSystemContext?: string;
+    systemPrompt?: string;
+    prependContext?: string;
+    appendSystemContext?: string;
+    modelOverride?: string;
+    providerOverride?: string;
+  };
+
+  export type PluginHookBeforeCompactionEvent = {
+    messageCount: number;
+    compactingCount?: number;
+    tokenCount?: number;
+    messages?: unknown[];
+    sessionFile?: string;
+  };
+
+  export type PluginHookBeforeResetEvent = {
+    sessionFile?: string;
+    messages?: unknown[];
+    reason?: string;
+  };
+
+  export type PluginHookSessionEndEvent = {
+    sessionId: string;
+    sessionKey?: string;
+    messageCount: number;
+    durationMs?: number;
+    reason?: string;
+    sessionFile?: string;
+  };
+
+  export type OpenClawPluginApi = {
+    id: string;
+    name: string;
+    runtime: PluginRuntime;
+    logger: PluginLogger;
+    pluginConfig?: Record<string, unknown>;
+    registerTool: (tool: {
+      name: string;
+      description: string;
+      parameters: Record<string, unknown>;
+      optional?: boolean;
+      execute: (id: string, params: Record<string, unknown>) => Promise<{
+        content: { type: string; text: string }[];
+      }>;
+    }) => void;
+    on: {
+      (
+        hookName: "before_agent_start",
+        handler: (
+          event: PluginHookBeforeAgentStartEvent,
+          ctx: PluginHookAgentContext,
+        ) =>
+          | Promise<PluginHookBeforeAgentStartResult | void>
+          | PluginHookBeforeAgentStartResult
+          | void,
+        opts?: { priority?: number },
+      ): void;
+      (
+        hookName: "before_compaction",
+        handler: (
+          event: PluginHookBeforeCompactionEvent,
+          ctx: PluginHookAgentContext,
+        ) => Promise<void> | void,
+        opts?: { priority?: number },
+      ): void;
+      (
+        hookName: "before_reset",
+        handler: (
+          event: PluginHookBeforeResetEvent,
+          ctx: PluginHookAgentContext,
+        ) => Promise<void> | void,
+        opts?: { priority?: number },
+      ): void;
+      (
+        hookName: "session_end",
+        handler: (
+          event: PluginHookSessionEndEvent,
+          ctx: PluginHookSessionContext,
+        ) => Promise<void> | void,
+        opts?: { priority?: number },
+      ): void;
+      (
+        hookName: PluginHookName,
+        handler: (event: unknown, ctx: unknown) => unknown,
+        opts?: { priority?: number },
+      ): void;
+    };
+  };
+
+  export type OpenClawPluginDefinition = {
+    id: string;
+    name: string;
+    description?: string;
+    version?: string;
+    register: (api: OpenClawPluginApi) => void | Promise<void>;
+  };
+
+  export function definePluginEntry(
+    def: OpenClawPluginDefinition,
+  ): OpenClawPluginDefinition;
+}
+
+declare module "openclaw/plugin-sdk/agent-runtime" {
+  export interface PreparedModel {
+    model: unknown;
+    auth: unknown;
+  }
+
+  export interface PreparedModelError {
+    error: string;
+  }
+
+  export function prepareSimpleCompletionModelForAgent(opts: {
+    cfg: unknown;
+    agentId: string;
+    modelRef?: string;
+  }): Promise<PreparedModel | PreparedModelError>;
+
+  export interface CompletionMessage {
+    role: string;
+    content: { type: string; text?: string }[];
+    timestamp: number;
+  }
+
+  export interface CompletionResult {
+    content: { type: string; text?: string }[];
+  }
+
+  export function completeWithPreparedSimpleCompletionModel(opts: {
+    model: unknown;
+    auth: unknown;
+    context: {
+      systemPrompt?: string;
+      messages: CompletionMessage[];
+    };
+    options?: { maxTokens?: number };
+  }): Promise<CompletionResult>;
+}

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["tests/**/*.test.ts"],
+  },
+});

package/plugin/vendor/reflexio/reflexio/lib/__init__.py

@@ -0,0 +1,23 @@
+"""Reflexio library package."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from reflexio.lib.reflexio_lib import Reflexio
+
+__all__ = ["Reflexio"]
+
+
+def __dir__() -> list[str]:
+    return __all__
+
+
+def __getattr__(name: str) -> type:
+    if name == "Reflexio":
+        from reflexio.lib.reflexio_lib import Reflexio
+
+        globals()["Reflexio"] = Reflexio  # cache after first access
+        return Reflexio
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

package/plugin/vendor/reflexio/reflexio/lib/_agent_playbook.py

@@ -0,0 +1,310 @@
+from reflexio.lib._base import (
+    STORAGE_NOT_CONFIGURED_MSG,
+    ReflexioBase,
+    _require_storage,
+)
+from reflexio.models.api_schema.retriever_schema import (
+    GetAgentPlaybooksRequest,
+    GetAgentPlaybooksResponse,
+    SearchAgentPlaybookRequest,
+    SearchAgentPlaybookResponse,
+    UpdateAgentPlaybookRequest,
+    UpdateAgentPlaybookResponse,
+    UpdatePlaybookStatusRequest,
+    UpdatePlaybookStatusResponse,
+)
+from reflexio.models.api_schema.service_schemas import (
+    AddAgentPlaybookRequest,
+    AddAgentPlaybookResponse,
+    AgentPlaybook,
+    BulkDeleteResponse,
+    DeleteAgentPlaybookRequest,
+    DeleteAgentPlaybookResponse,
+    DeleteAgentPlaybooksByIdsRequest,
+    PlaybookAggregationChangeLogResponse,
+)
+from reflexio.models.config_schema import SearchOptions
+from reflexio.server.tracing import profile_step
+
+
+class AgentPlaybookMixin(ReflexioBase):
+    def get_playbook_aggregation_change_logs(
+        self, playbook_name: str, agent_version: str
+    ) -> PlaybookAggregationChangeLogResponse:
+        """Get playbook aggregation change logs.
+
+        Args:
+            playbook_name (str): Playbook name to filter by
+            agent_version (str): Agent version to filter by
+
+        Returns:
+            PlaybookAggregationChangeLogResponse: Response containing change logs
+        """
+        if not self._is_storage_configured():
+            return PlaybookAggregationChangeLogResponse(success=True, change_logs=[])
+        change_logs = self._get_storage().get_playbook_aggregation_change_logs(
+            playbook_name=playbook_name, agent_version=agent_version
+        )
+        return PlaybookAggregationChangeLogResponse(
+            success=True, change_logs=change_logs
+        )
+
+    @_require_storage(DeleteAgentPlaybookResponse)
+    def delete_agent_playbook(
+        self,
+        request: DeleteAgentPlaybookRequest | dict,
+    ) -> DeleteAgentPlaybookResponse:
+        """Delete an agent playbook by ID.
+
+        Args:
+            request (DeleteAgentPlaybookRequest): The delete request containing agent_playbook_id
+
+        Returns:
+            DeleteAgentPlaybookResponse: Response containing success status and message
+        """
+        if isinstance(request, dict):
+            request = DeleteAgentPlaybookRequest(**request)
+        self._get_storage().delete_agent_playbook(request.agent_playbook_id)
+        return DeleteAgentPlaybookResponse(success=True, message="Deleted successfully")
+
+    @_require_storage(BulkDeleteResponse)
+    def delete_all_playbooks_bulk(self) -> BulkDeleteResponse:
+        """Delete all playbooks (both user and agent).
+
+        Cascading variant — wipes both playbook stores. For per-entity
+        semantics use :meth:`delete_all_agent_playbooks_bulk` (agent only)
+        or :meth:`UserPlaybookMixin.delete_all_user_playbooks_bulk`
+        (user only).
+
+        Returns:
+            BulkDeleteResponse: Response containing success status and deleted count
+        """
+        self._get_storage().delete_all_agent_playbooks()
+        self._get_storage().delete_all_user_playbooks()
+        return BulkDeleteResponse(success=True, message="Deleted successfully")
+
+    @_require_storage(BulkDeleteResponse)
+    def delete_all_agent_playbooks_bulk(self) -> BulkDeleteResponse:
+        """Delete all agent playbooks (only agent playbooks, not user playbooks).
+
+        Unlike :meth:`delete_all_playbooks_bulk` (which cascades to both
+        user and agent playbooks), this method scopes the deletion
+        strictly to agent playbooks. Use this from CLI or API callers
+        that want per-entity semantics.
+
+        Returns:
+            BulkDeleteResponse: Response containing success status and message.
+        """
+        self._get_storage().delete_all_agent_playbooks()
+        return BulkDeleteResponse(success=True, message="Deleted successfully")
+
+    @_require_storage(BulkDeleteResponse)
+    def delete_agent_playbooks_by_ids_bulk(
+        self,
+        request: DeleteAgentPlaybooksByIdsRequest | dict,
+    ) -> BulkDeleteResponse:
+        """Delete agent playbooks by their IDs.
+
+        Args:
+            request (DeleteAgentPlaybooksByIdsRequest): The delete request containing agent_playbook_ids
+
+        Returns:
+            BulkDeleteResponse: Response containing success status and deleted count
+        """
+        if isinstance(request, dict):
+            request = DeleteAgentPlaybooksByIdsRequest(**request)
+        self._get_storage().delete_agent_playbooks_by_ids(request.agent_playbook_ids)
+        return BulkDeleteResponse(
+            success=True,
+            deleted_count=len(request.agent_playbook_ids),
+            message=f"Deleted {len(request.agent_playbook_ids)} item(s)",
+        )
+
+    def add_agent_playbook(
+        self,
+        request: AddAgentPlaybookRequest | dict,
+    ) -> AddAgentPlaybookResponse:
+        """Add agent playbooks directly to storage.
+
+        Args:
+            request (Union[AddAgentPlaybookRequest, dict]): The add request containing agent playbooks
+
+        Returns:
+            AddAgentPlaybookResponse: Response containing success status, message, and count of added playbooks
+        """
+        if not self._is_storage_configured():
+            return AddAgentPlaybookResponse(
+                success=False, message=STORAGE_NOT_CONFIGURED_MSG
+            )
+        if isinstance(request, dict):
+            request = AddAgentPlaybookRequest(**request)
+
+        try:
+            # Normalize playbooks - only keep required fields, reset others to defaults.
+            # Top-level structured fields (trigger, rationale) are preserved so CLI
+            # callers and the aggregation pipeline don't lose them.
+            normalized_playbooks = [
+                AgentPlaybook(
+                    agent_version=fb.agent_version,
+                    playbook_name=fb.playbook_name,
+                    content=fb.content,
+                    trigger=fb.trigger,
+                    rationale=fb.rationale,
+                    playbook_status=fb.playbook_status,
+                    playbook_metadata=(fb.playbook_metadata or ""),
+                )
+                for fb in request.agent_playbooks
+            ]
+
+            self._get_storage().save_agent_playbooks(normalized_playbooks)
+            return AddAgentPlaybookResponse(
+                success=True,
+                added_count=len(normalized_playbooks),
+                message=f"Added {len(normalized_playbooks)} item(s)",
+            )
+        except Exception as e:
+            return AddAgentPlaybookResponse(success=False, message=str(e))
+
+    def get_agent_playbooks(
+        self,
+        request: GetAgentPlaybooksRequest | dict,
+    ) -> GetAgentPlaybooksResponse:
+        """Get agent playbooks.
+
+        Args:
+            request (Union[GetAgentPlaybooksRequest, dict]): The get request
+
+        Returns:
+            GetAgentPlaybooksResponse: Response containing agent playbooks
+        """
+        if not self._is_storage_configured():
+            return GetAgentPlaybooksResponse(
+                success=True, agent_playbooks=[], msg=STORAGE_NOT_CONFIGURED_MSG
+            )
+        if isinstance(request, dict):
+            request = GetAgentPlaybooksRequest(**request)
+
+        try:
+            agent_playbooks = self._get_storage().get_agent_playbooks(
+                limit=request.limit or 100,
+                playbook_name=request.playbook_name,
+                agent_version=request.agent_version,
+                status_filter=request.status_filter,
+                playbook_status_filter=[request.playbook_status_filter]
+                if request.playbook_status_filter
+                else None,
+            )
+            return GetAgentPlaybooksResponse(
+                success=True,
+                agent_playbooks=agent_playbooks,
+                msg=f"Found {len(agent_playbooks)} agent playbook(s)",
+            )
+        except Exception as e:
+            return GetAgentPlaybooksResponse(
+                success=False, agent_playbooks=[], msg=str(e)
+            )
+
+    def search_agent_playbooks(
+        self,
+        request: SearchAgentPlaybookRequest | dict,
+    ) -> SearchAgentPlaybookResponse:
+        """Search agent playbooks with advanced filtering and semantic search.
+
+        Args:
+            request (Union[SearchAgentPlaybookRequest, dict]): The search request
+
+        Returns:
+            SearchAgentPlaybookResponse: Response containing matching agent playbooks
+        """
+        if not self._is_storage_configured():
+            return SearchAgentPlaybookResponse(
+                success=True, agent_playbooks=[], msg=STORAGE_NOT_CONFIGURED_MSG
+            )
+        if isinstance(request, dict):
+            request = SearchAgentPlaybookRequest(**request)
+
+        try:
+            query = (
+                self._reformulate_query(
+                    request.query, enabled=bool(request.enable_reformulation)
+                )
+                or request.query
+            )
+            search_request = request.model_copy(update={"query": query})
+            query_embedding = self._maybe_get_query_embedding(
+                search_request.query, search_request.search_mode
+            )
+            options = (
+                SearchOptions(query_embedding=query_embedding)
+                if query_embedding
+                else None
+            )
+            with profile_step(
+                "search.storage",
+                entity_type="agent_playbooks",
+                search_mode=search_request.search_mode,
+                top_k=search_request.top_k,
+            ) as span:
+                agent_playbooks = self._get_storage().search_agent_playbooks(
+                    search_request, options
+                )
+                span.set_data("result_count", len(agent_playbooks))
+            return SearchAgentPlaybookResponse(
+                success=True,
+                agent_playbooks=agent_playbooks,
+                msg=f"Found {len(agent_playbooks)} matching agent playbook(s)",
+            )
+        except Exception as e:
+            return SearchAgentPlaybookResponse(
+                success=False, agent_playbooks=[], msg=str(e)
+            )
+
+    @_require_storage(UpdatePlaybookStatusResponse, msg_field="msg")
+    def update_agent_playbook_status(
+        self,
+        request: UpdatePlaybookStatusRequest | dict,
+    ) -> UpdatePlaybookStatusResponse:
+        """Update the status of a specific agent playbook.
+
+        Args:
+            request (Union[UpdatePlaybookStatusRequest, dict]): The update request
+
+        Returns:
+            UpdatePlaybookStatusResponse: Response containing success status and message
+        """
+        if isinstance(request, dict):
+            request = UpdatePlaybookStatusRequest(**request)
+        self._get_storage().update_agent_playbook_status(
+            agent_playbook_id=request.agent_playbook_id,
+            playbook_status=request.playbook_status,
+        )
+        return UpdatePlaybookStatusResponse(
+            success=True, msg="Playbook status updated successfully"
+        )
+
+    @_require_storage(UpdateAgentPlaybookResponse, msg_field="msg")
+    def update_agent_playbook(
+        self,
+        request: UpdateAgentPlaybookRequest | dict,
+    ) -> UpdateAgentPlaybookResponse:
+        """Update editable fields of an agent playbook.
+
+        Args:
+            request (Union[UpdateAgentPlaybookRequest, dict]): The update request
+
+        Returns:
+            UpdateAgentPlaybookResponse: Response containing success status and message
+        """
+        if isinstance(request, dict):
+            request = UpdateAgentPlaybookRequest(**request)
+        self._get_storage().update_agent_playbook(
+            agent_playbook_id=request.agent_playbook_id,
+            playbook_name=request.playbook_name,
+            content=request.content,
+            trigger=request.trigger,
+            rationale=request.rationale,
+            playbook_status=request.playbook_status,
+        )
+        return UpdateAgentPlaybookResponse(
+            success=True, msg="Agent playbook updated successfully"
+        )