@picahq/toolkit 0.1.0

package/dist/apis/execute.js

@@ -0,0 +1,185 @@
+/**
+ * Pica ToolKit - Execute API
+ *
+ * This is the execute API for the Pica ToolKit.
+ * This API executes actions on connected platforms via the Pica Passthrough API.
+ *
+ * @fileoverview Execute API for the Pica ToolKit
+ * @author Pica
+ */
+import axios from "axios";
+import FormData from "form-data";
+import { normalizeActionId, resolveTemplateVariables } from "../utils";
+import { listConnections } from "./connections";
+import { getActionSpec } from "./action";
+const PASSTHROUGH_URL = "/v1/passthrough";
+/**
+ * Execute an action
+ * @param baseUrl - The base URL of the Pica API
+ * @param secret - The Pica API key
+ * @param actionSystemId - The system ID of the action to execute
+ * @param connectionKey - The connection key to use for executing the action
+ * @param data - The data to execute the action with
+ * @param pathVariables - The path variables to execute the action with
+ * @param queryParams - The query parameters to execute the action with
+ * @param headers - The headers to execute the action with
+ * @param isFormData - Whether to execute the action as a form data request
+ * @param isFormUrlEncoded - Whether to execute the action as a form urlencoded request
+ * @param returnRequestConfigWithoutExecution - Whether to return request config without executing
+ * @param options - The options for the Pica client
+ * @returns The response from the action
+ */
+export async function executeAction({ baseUrl, secret, actionSystemId, connectionKey, data, pathVariables, queryParams, headers, isFormData, isFormUrlEncoded, returnRequestConfigWithoutExecution, options, }) {
+    await validateConnectionKey(baseUrl, secret, connectionKey, options);
+    const action = await getActionSpec(baseUrl, secret, actionSystemId, options);
+    if (!action) {
+        throw new Error(`Could not fetch knowledge for action system ID: ${actionSystemId}`);
+    }
+    // For custom actions, always include connection key in the data
+    if (action.tags.includes("custom")) {
+        const customData = {
+            ...data,
+            connectionKey
+        };
+        data = customData;
+    }
+    // Resolve template variables in the action path
+    const { resolvedPath, cleanedData } = resolveTemplateVariables(action.path, data, pathVariables);
+    // Execute passthrough request
+    return await executePassthrough({
+        baseUrl,
+        secret,
+        actionId: normalizeActionId(actionSystemId),
+        connectionKey,
+        data: cleanedData,
+        path: resolvedPath,
+        method: action.method,
+        queryParams,
+        headers,
+        isFormData,
+        isFormUrlEncoded,
+        returnRequestConfigWithoutExecution
+    });
+}
+/**
+ * Validate the connection key
+ * @param baseUrl - The base URL of the Pica API
+ * @param secret - The Pica API key
+ * @param connectionKey - The connection key to validate
+ * @param options - The options for the Pica client
+ * @throws An error if the connection key does not exist or is not accessible
+ */
+async function validateConnectionKey(baseUrl, secret, connectionKey, options) {
+    const connections = await listConnections({ baseUrl, secret, options });
+    const connectionExists = connections.some(conn => conn.key === connectionKey);
+    if (!connectionExists) {
+        throw new Error(`Connection key '${connectionKey}' does not exist or is not accessible.`);
+    }
+}
+/**
+ * Execute a passthrough request
+ * @param baseUrl - The base URL of the Pica API
+ * @param secret - The Pica API key
+ * @param actionId - The ID of the action to execute
+ * @param connectionKey - The connection key to use for executing the action
+ * @param data - The data to execute the action with
+ * @param path - The path to execute the action on
+ * @param method - The method to execute the action with
+ * @param queryParams - The query parameters to execute the action with
+ * @param headers - The headers to execute the action with
+ * @param isFormData - Whether to execute the action as a form data request
+ * @param isFormUrlEncoded - Whether to execute the action as a form urlencoded request
+ * @param returnRequestConfigWithoutExecution - Whether to return request config without executing
+ * @returns The response from the passthrough request
+ */
+async function executePassthrough({ baseUrl, secret, actionId, connectionKey, data, path, method, queryParams, headers, isFormData, isFormUrlEncoded, returnRequestConfigWithoutExecution }) {
+    try {
+        const allHeaders = {
+            "Content-Type": "application/json",
+            "x-pica-secret": secret,
+            "x-pica-connection-key": connectionKey,
+            "x-pica-action-id": actionId,
+            ...(isFormData ? { "Content-Type": "multipart/form-data" } : {}),
+            ...(isFormUrlEncoded ? { "Content-Type": "application/x-www-form-urlencoded" } : {}),
+            ...headers
+        };
+        // Remove Content-Type header if no data is being sent
+        const finalHeaders = !data
+            ? Object.entries(allHeaders)
+                .filter(([key]) => key.toLowerCase() !== "content-type")
+                .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {})
+            : allHeaders;
+        const url = `${baseUrl}${PASSTHROUGH_URL}${path.startsWith("/") ? path : "/" + path}`;
+        const requestConfig = {
+            url,
+            method,
+            headers: finalHeaders,
+            params: queryParams
+        };
+        if (method?.toLowerCase() !== "get") {
+            if (isFormData) {
+                const formData = new FormData();
+                if (data && typeof data === "object" && !Array.isArray(data)) {
+                    Object.entries(data).forEach(([key, value]) => {
+                        if (typeof value === "object") {
+                            formData.append(key, JSON.stringify(value));
+                        }
+                        else {
+                            formData.append(key, String(value));
+                        }
+                    });
+                }
+                requestConfig.data = formData;
+                const formHeaders = formData.getHeaders();
+                requestConfig.headers = {
+                    ...requestConfig.headers,
+                    ...formHeaders
+                };
+            }
+            else if (isFormUrlEncoded) {
+                const params = new URLSearchParams();
+                if (data && typeof data === "object" && !Array.isArray(data)) {
+                    Object.entries(data).forEach(([key, value]) => {
+                        if (typeof value === "object") {
+                            params.append(key, JSON.stringify(value));
+                        }
+                        else {
+                            params.append(key, String(value));
+                        }
+                    });
+                }
+                requestConfig.data = params.toString();
+            }
+            else {
+                requestConfig.data = data;
+            }
+        }
+        // Return request config without execution if requested
+        if (returnRequestConfigWithoutExecution) {
+            requestConfig.headers['x-pica-secret'] = "YOUR_PICA_SECRET_KEY_HERE";
+            return {
+                executed: false,
+                requestConfig
+            };
+        }
+        const response = await axios(requestConfig);
+        return {
+            success: true,
+            responseData: response.data,
+            requestConfig: {
+                ...requestConfig,
+                headers: {
+                    ...requestConfig.headers,
+                    "x-pica-secret": "****REDACTED****"
+                }
+            }
+        };
+    }
+    catch (error) {
+        console.error("Error executing passthrough request:", error);
+        return {
+            success: false,
+            error: JSON.stringify(error)
+        };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Pica ToolKit - Main Entry Point
+ *
+ * This is the main entry point for the Pica ToolKit.
+ *
+ * @fileoverview Main entry point for the Pica ToolKit
+ * @author Pica
+ */
+import { ToolSet } from "ai";
+import { PicaOptions, Connection, Connector, AvailableAction } from "./types";
+export declare class Pica {
+    private secret;
+    private baseUrl;
+    private options?;
+    constructor(secret: string, options?: PicaOptions);
+    private logConnectorInitialization;
+    private logActionInitialization;
+    /**
+     * @returns The system prompt for the Pica ToolKit
+     */
+    getSystemPrompt(): Promise<string>;
+    /**
+     * @returns List of connected integrations
+     */
+    getConnectedIntegrations(): Promise<Connection[]>;
+    /**
+     * @returns List of all available connectors in Pica
+     */
+    getAvailableConnectors(): Promise<Connector[]>;
+    /**
+     * @param platform - The platform to get all available actions for
+     * @returns List of all available actions for a given platform
+     */
+    getAvailableActions(platform: string): Promise<AvailableAction[]>;
+    tools(): ToolSet;
+}

package/dist/index.js

@@ -0,0 +1,228 @@
+/**
+ * Pica ToolKit - Main Entry Point
+ *
+ * This is the main entry point for the Pica ToolKit.
+ *
+ * @fileoverview Main entry point for the Pica ToolKit
+ * @author Pica
+ */
+import { tool } from "ai";
+import chalk from "chalk";
+import { executeAction } from "./apis/execute";
+import { listConnections, clean } from "./apis/connections";
+import { searchPlatformActions, getActionsKnowledge } from "./apis/action";
+import { getAvailableActions } from "./apis/available-actions";
+import { getAvailableConnectors } from "./apis/available-connectors";
+import { generateDefaultSystemPrompt } from "./prompts/default";
+import { generateKnowledgeAgentSystemPrompt } from "./prompts/knowledge";
+import { LIST_PICA_INTEGRATIONS_TOOL_CONFIG, SEARCH_PLATFORM_ACTIONS_TOOL_CONFIG, GET_ACTIONS_KNOWLEDGE_TOOL_CONFIG, EXECUTE_ACTION_TOOL_CONFIG, KNOWLEDGE_AGENT_EXECUTE_ACTION_TOOL_CONFIG, PROMPT_TO_CONNECT_INTEGRATION_TOOL_CONFIG } from "./schemas";
+import { isInitializingWithAllConnectors, isInitializingWithAllActions, pluralize, LOG_MESSAGES } from "./utils";
+export class Pica {
+    secret;
+    baseUrl = "https://api.picaos.com";
+    options;
+    constructor(secret, options) {
+        if (!secret) {
+            throw new Error("A valid Pica API key must be provided. You can obtain your API key from the Pica dashboard: https://app.picaos.com/settings/api-keys");
+        }
+        this.secret = secret;
+        this.baseUrl = options?.serverUrl || "https://api.picaos.com";
+        this.options = options;
+        // Knowledge Agent Mode initialization
+        if (this.options?.knowledgeAgent) {
+            console.log(chalk.green.bold(LOG_MESSAGES.KNOWLEDGE_AGENT_INITIALIZED));
+            console.log(chalk.yellow(LOG_MESSAGES.KNOWLEDGE_AGENT_ACTIONS_ACCESS));
+            console.log(chalk.yellow(LOG_MESSAGES.KNOWLEDGE_AGENT_EXECUTE_CONFIG));
+            console.log(chalk.gray(LOG_MESSAGES.KNOWLEDGE_AGENT_CONNECTIONS_DISABLED));
+            if (this.options?.authkit) {
+                console.log(chalk.blue(LOG_MESSAGES.AUTHKIT_ENABLED));
+            }
+            return;
+        }
+        // Standard mode initialization
+        this.logConnectorInitialization();
+        this.logActionInitialization();
+        if (this.options?.authkit) {
+            console.log(chalk.blue(LOG_MESSAGES.AUTHKIT_ENABLED));
+        }
+    }
+    logConnectorInitialization() {
+        if (isInitializingWithAllConnectors(this.options?.connectors)) {
+            console.log(chalk.cyan(LOG_MESSAGES.ALL_CONNECTORS_ACCESS));
+            console.log(chalk.magenta(LOG_MESSAGES.LIST_CONNECTIONS_ENABLED));
+        }
+        else {
+            const connectorCount = this.options?.connectors?.length || 0;
+            console.log(chalk.cyan(LOG_MESSAGES.connectorCount(connectorCount, pluralize(connectorCount, 'connector'))));
+            console.log(chalk.magenta(LOG_MESSAGES.LIST_CONNECTIONS_DISABLED));
+        }
+    }
+    logActionInitialization() {
+        if (isInitializingWithAllActions(this.options?.actions)) {
+            console.log(chalk.cyan(LOG_MESSAGES.ALL_ACTIONS_ACCESS));
+        }
+        else {
+            const actionCount = this.options?.actions?.length || 0;
+            console.log(chalk.cyan(LOG_MESSAGES.actionCount(actionCount, pluralize(actionCount, 'action'))));
+        }
+    }
+    /**
+     * @returns The system prompt for the Pica ToolKit
+     */
+    async getSystemPrompt() {
+        if (this.options?.knowledgeAgent) {
+            return generateKnowledgeAgentSystemPrompt();
+        }
+        return generateDefaultSystemPrompt(this.options?.connectors, this.options?.actions);
+    }
+    /**
+     * @returns List of connected integrations
+     */
+    async getConnectedIntegrations() {
+        return await listConnections({
+            baseUrl: this.baseUrl,
+            secret: this.secret,
+            options: this.options
+        });
+    }
+    /**
+     * @returns List of all available connectors in Pica
+     */
+    async getAvailableConnectors() {
+        return await getAvailableConnectors({
+            baseUrl: this.baseUrl,
+            secret: this.secret,
+            options: this.options
+        });
+    }
+    /**
+     * @param platform - The platform to get all available actions for
+     * @returns List of all available actions for a given platform
+     */
+    async getAvailableActions(platform) {
+        return await getAvailableActions({
+            baseUrl: this.baseUrl,
+            secret: this.secret,
+            platform,
+            options: this.options
+        });
+    }
+    tools() {
+        const tools = {};
+        // Knowledge agents don't need connection management tools
+        if (!this.options?.knowledgeAgent && isInitializingWithAllConnectors(this.options?.connectors)) {
+            tools.listPicaIntegrations = tool({
+                name: LIST_PICA_INTEGRATIONS_TOOL_CONFIG.name,
+                description: LIST_PICA_INTEGRATIONS_TOOL_CONFIG.description,
+                inputSchema: LIST_PICA_INTEGRATIONS_TOOL_CONFIG.schema,
+                outputSchema: LIST_PICA_INTEGRATIONS_TOOL_CONFIG.outputSchema,
+                execute: async () => {
+                    const connections = await listConnections({
+                        baseUrl: this.baseUrl,
+                        secret: this.secret,
+                        options: this.options
+                    });
+                    return clean(connections);
+                }
+            });
+        }
+        tools.searchPlatformActions = tool({
+            name: SEARCH_PLATFORM_ACTIONS_TOOL_CONFIG.name,
+            description: SEARCH_PLATFORM_ACTIONS_TOOL_CONFIG.description,
+            inputSchema: SEARCH_PLATFORM_ACTIONS_TOOL_CONFIG.schema,
+            outputSchema: SEARCH_PLATFORM_ACTIONS_TOOL_CONFIG.outputSchema,
+            execute: async ({ platform, query }) => {
+                if (!this.options?.knowledgeAgent && !isInitializingWithAllActions(this.options?.actions) && this.options?.actions?.length === 0) {
+                    throw new Error("No actions are available. Please initialize the client with specific action ids or ['*'] for all actions.");
+                }
+                const actions = await searchPlatformActions({
+                    baseUrl: this.baseUrl,
+                    secret: this.secret,
+                    platform,
+                    query,
+                    options: this.options?.knowledgeAgent ? { ...this.options, actions: ["*"] } : this.options
+                });
+                return actions;
+            }
+        });
+        tools.getActionsKnowledge = tool({
+            name: GET_ACTIONS_KNOWLEDGE_TOOL_CONFIG.name,
+            description: GET_ACTIONS_KNOWLEDGE_TOOL_CONFIG.description,
+            inputSchema: GET_ACTIONS_KNOWLEDGE_TOOL_CONFIG.schema,
+            outputSchema: GET_ACTIONS_KNOWLEDGE_TOOL_CONFIG.outputSchema,
+            execute: async ({ systemIds }) => {
+                const knowledgeMap = await getActionsKnowledge({
+                    baseUrl: this.baseUrl,
+                    secret: this.secret,
+                    systemIds,
+                    options: this.options?.knowledgeAgent ? { ...this.options, actions: ["*"] } : this.options
+                });
+                return knowledgeMap;
+            }
+        });
+        if (this.options?.knowledgeAgent) {
+            tools.execute = tool({
+                name: KNOWLEDGE_AGENT_EXECUTE_ACTION_TOOL_CONFIG.name,
+                description: KNOWLEDGE_AGENT_EXECUTE_ACTION_TOOL_CONFIG.description,
+                inputSchema: KNOWLEDGE_AGENT_EXECUTE_ACTION_TOOL_CONFIG.schema,
+                outputSchema: KNOWLEDGE_AGENT_EXECUTE_ACTION_TOOL_CONFIG.outputSchema,
+                execute: async (params) => {
+                    const result = await executeAction({
+                        baseUrl: this.baseUrl,
+                        secret: this.secret,
+                        actionSystemId: params.actionSystemId,
+                        connectionKey: params.connectionKey,
+                        data: params.data,
+                        pathVariables: params.pathVariables,
+                        queryParams: params.queryParams,
+                        headers: params.headers,
+                        isFormData: params.isFormData,
+                        isFormUrlEncoded: params.isFormUrlEncoded,
+                        returnRequestConfigWithoutExecution: true,
+                        options: this.options
+                    });
+                    return result;
+                }
+            });
+        }
+        else {
+            tools.execute = tool({
+                name: EXECUTE_ACTION_TOOL_CONFIG.name,
+                description: EXECUTE_ACTION_TOOL_CONFIG.description,
+                inputSchema: EXECUTE_ACTION_TOOL_CONFIG.schema,
+                outputSchema: EXECUTE_ACTION_TOOL_CONFIG.outputSchema,
+                execute: async (params) => {
+                    const result = await executeAction({
+                        baseUrl: this.baseUrl,
+                        secret: this.secret,
+                        actionSystemId: params.actionSystemId,
+                        connectionKey: params.connectionKey,
+                        data: params.data,
+                        pathVariables: params.pathVariables,
+                        queryParams: params.queryParams,
+                        headers: params.headers,
+                        isFormData: params.isFormData,
+                        isFormUrlEncoded: params.isFormUrlEncoded,
+                        returnRequestConfigWithoutExecution: false,
+                        options: this.options
+                    });
+                    return result;
+                }
+            });
+        }
+        if (this.options?.authkit) {
+            tools.promptToConnectIntegration = tool({
+                name: PROMPT_TO_CONNECT_INTEGRATION_TOOL_CONFIG.name,
+                description: PROMPT_TO_CONNECT_INTEGRATION_TOOL_CONFIG.description,
+                inputSchema: PROMPT_TO_CONNECT_INTEGRATION_TOOL_CONFIG.schema,
+                outputSchema: PROMPT_TO_CONNECT_INTEGRATION_TOOL_CONFIG.outputSchema,
+                execute: async ({ platformName }) => {
+                    return {
+                        response: platformName
+                    };
+                }
+            });
+        }
+        return tools;
+    }
+}

package/dist/prompts/default.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Pica ToolKit - Default System Prompt
+ *
+ * This is the default system prompt for the Pica ToolKit.
+ * Contains the usage instructions for all the Pica tools.
+ *
+ * @fileoverview Default system prompt for the Pica ToolKit
+ * @author Pica
+ */
+/**
+ * Generates the default system prompt with optional connector and action information
+ * @param connectors - Array of connector keys to include in the prompt
+ * @param actions - Array of action systemIds to include in the prompt
+ * @returns The formatted system prompt string
+ */
+export declare const generateDefaultSystemPrompt: (connectors?: string[], actions?: string[]) => string;

package/dist/prompts/default.js

@@ -0,0 +1,114 @@
+/**
+ * Pica ToolKit - Default System Prompt
+ *
+ * This is the default system prompt for the Pica ToolKit.
+ * Contains the usage instructions for all the Pica tools.
+ *
+ * @fileoverview Default system prompt for the Pica ToolKit
+ * @author Pica
+ */
+import { isInitializingWithAllConnectors, isInitializingWithAllActions, parseConnectionKey, pluralize } from "../utils";
+const INTEGRATIONS_TOOL_PLACEHOLDER = '{{LIST_PICA_INTEGRATIONS_TOOL_CONFIG}}';
+const LIST_PICA_INTEGRATIONS_TOOL_CONFIG = `
+Tool: **listPicaConnections** - A tool to list user's connected integrations
+  - Shows available platforms and their connection keys
+  - Use connection keys EXACTLY as provided (including prefixes like 'test::')
+`;
+const DEFAULT_SYSTEM_PROMPT = `
+=== PICA: INTEGRATION ASSISTANT ===\n
+Everything below is for Pica, your integration assistant that can instantly connect your AI agents to external APIs.
+
+Current Time: ${new Date().toLocaleString('en-US', { timeZone: 'GMT' })} (GMT)
+${INTEGRATIONS_TOOL_PLACEHOLDER}
+## Workflow rules you MUST follow for every request:
+
+Step 1: **searchPlatformActions** - Find available actions on a platform  
+  - Search by platform name (e.g., 'google-sheets', 'posthog', 'notion')
+  - When passing the query, pass a descriptive intent phrase without the platform name. 
+    For example, if the platform is 'gmail', and the user's main query is 
+    "Fetch my 5 latest emails from Gmail and research the senders using exa",
+    then the query for getting Gmail actions should be {platform: gmail, query: "Fetch my 5 latest emails"}.
+    Another request would be then made for {platform: exa, query: "Research a sender"}.
+  - When you are selecting the action, select the action that is most relevant to the user's query. 
+    If you are between two very similar actions and one has a 'custom' tag, select the action with the 'custom' tag.
+  - Returns actions with system IDs and basic info
+
+Step 2: **getActionsKnowledge** - Get detailed documentation for actions
+  - Takes array of system IDs from search results
+  - Returns comprehensive API documentation and usage examples
+  - Essential before executing actions
+
+Step 3: **execute** - Execute an action on a connected platform   
+  IMPORTANT: Must always call getActionsKnowledge before executing an action.
+
+  Required Parameters:
+  * platform: The target platform (e.g., 'google-sheets', 'posthog')
+  * actionSystemId: The action system ID from searchPlatformActions results
+  * connectionKey: The connection key for authentication (use exactly as provided)
+  * data: The request payload
+
+  Optional Parameters:
+  * pathVariables: Values for path template variables like {{spreadsheetId}}
+  * queryParams: Query parameters to append to the URL
+  * headers: Additional HTTP headers
+  * isFormData: Set to true to send data as multipart/form-data
+  * isFormUrlEncoded: Set to true to send data as application/x-www-form-urlencoded
+
+## Best Practices:
+- **Always use keys VERBATIM**: Connection keys and system IDs must be used exactly as returned
+- **Follow the workflow**: search → knowledge → execute for best results
+- **Read documentation**: Use getActionsKnowledge tool before executing any actions
+- **Handle templates**: Path variables like {{spreadsheetId}} need actual values provided in pathVariables
+- **Use correct data format**: Check if action requires isFormData or isFormUrlEncoded based on API requirements
+- **Provide clear summaries**: Explain what actions were taken and results achieved
+- **Confirm with user**: Before executing a destructive action, confirm with the user that you have the correct action and data.
+
+## Error Handling:
+- If actions fail, read the error message, check required parameters from the knowledge and then try again with the correct parameters.
+- Always provide helpful error messages and next steps
+- Ask the user for additional information if needed
+
+### Smart Error Recovery:
+- When execution fails, intelligently search for alternative actions based on the failed action's error message and intent.
+- Fetch the actions knowledge for the alternative actions and then execute the alternative action.
+- Perform this until the action succeeds or there are no more alternative actions.
+
+Be thorough, accurate, and helpful in assisting users with their integration workflows.
+`;
+/**
+ * Builds a formatted section listing connected integrations
+ * @param connectors - Array of connector keys to format
+ * @returns Formatted string of connected integrations or empty string
+ */
+const buildConnectedIntegrationsSection = (connectors) => {
+    return connectors?.map(connector => {
+        const { platform } = parseConnectionKey(connector);
+        return `- ${platform} (connection key: '${connector}')`;
+    }).join('\n') || "";
+};
+/**
+ * Generates the default system prompt with optional connector and action information
+ * @param connectors - Array of connector keys to include in the prompt
+ * @param actions - Array of action systemIds to include in the prompt
+ * @returns The formatted system prompt string
+ */
+export const generateDefaultSystemPrompt = (connectors, actions) => {
+    const shouldShowAllConnectors = isInitializingWithAllConnectors(connectors);
+    const shouldShowAllActions = isInitializingWithAllActions(actions);
+    const toolConfig = shouldShowAllConnectors ? LIST_PICA_INTEGRATIONS_TOOL_CONFIG : "";
+    let systemPrompt = DEFAULT_SYSTEM_PROMPT.replace(INTEGRATIONS_TOOL_PLACEHOLDER, toolConfig);
+    if (!shouldShowAllConnectors && connectors?.length) {
+        const connectionsSection = buildConnectedIntegrationsSection(connectors);
+        systemPrompt += `\nConnected integrations:\n${connectionsSection}`;
+    }
+    if (!shouldShowAllActions) {
+        const actionCount = actions?.length || 0;
+        if (actionCount === 0) {
+            systemPrompt += `\n\nAvailable Actions:\nNo actions are currently available. To enable actions, the client must be initialized with specific action ids or "*" for all actions.`;
+        }
+        else {
+            systemPrompt += `\n\nAvailable Actions:\nClient has access to ${actionCount} ${pluralize(actionCount, 'action')}. Only these actions will be available when searching or executing.`;
+        }
+    }
+    return systemPrompt;
+};

package/dist/prompts/knowledge.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Pica ToolKit - Knowledge Agent System Prompt
+ *
+ * This is the knowledge agent system prompt for the Pica ToolKit.
+ * Used when knowledgeAgent mode is enabled to generate Edge Function prompts.
+ *
+ * @fileoverview Knowledge agent system prompt for the Pica ToolKit
+ * @author Pica
+ */
+/**
+ * Generates the knowledge agent system prompt
+ * Knowledge agents have access to all actions by default and don't need connection management
+ * @returns The formatted knowledge agent system prompt string
+ */
+export declare const generateKnowledgeAgentSystemPrompt: () => string;