indusagi 0.13.7 → 0.13.8

package/dist/types/connectors-saas/saas/render/summarizers.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The pluggable result-summarizer registry.
+ *
+ * When a remote operation returns, the bridge wants *one short line* describing
+ * what came back — for a log entry, a status header, or a glance in the tool list.
+ * Different toolkits want different one-liners: a mail send is best summarized by
+ * its recipient, a list endpoint by its row count, a search by its top hit. Rather
+ * than bake a tower of `if (toolkit === …)` branches into one formatter, the choice
+ * is a lookup: {@link SUMMARIZERS} maps a toolkit slug (or a `prefix:*` glob) to a
+ * `(result) => string`, and {@link summarizeResult} picks the most specific match,
+ * falling back to a generic compact JSON preview.
+ *
+ * The default summarizer is the interesting one. It produces a short preview of the
+ * payload while **deduping repeated blobs**: large structured responses often carry
+ * the same nested object many times (the same author on every row, the same schema
+ * on every field), and naively previewing them buries the signal. So the default
+ * walks the payload *iteratively* — an explicit stack, never recursion, so a deep or
+ * cyclic response can never blow the call stack — content-hashes every object and
+ * array it meets, and replaces any repeat with a back-reference to where it first
+ * appeared. The result is a compact, de-duplicated sketch of the shape.
+ */
+import type { RemoteResult } from "../core/port";
+/**
+ * A function that renders one {@link RemoteResult} into a single human-readable
+ * line. Registered against a toolkit slug or a `prefix:*` pattern in
+ * {@link SUMMARIZERS} and selected by {@link summarizeResult}.
+ */
+export type Summarizer = (result: RemoteResult) => string;
+/**
+ * The toolkit slug a `<toolkit>_<operation>` (or `<toolkit>.<operation>`) tool name
+ * implies, lower-cased. Plain names with no separator are returned whole. This is
+ * what {@link summarizeResult} keys the registry lookup on.
+ */
+export declare function toolkitOf(toolName: string): string;
+/**
+ * The fallback summarizer used when no toolkit-specific entry matches.
+ *
+ * A failure renders as its error line; a success renders as a deduped JSON preview
+ * of its payload (see {@link previewPayload}). The line is always length-clamped.
+ */
+export declare function defaultSummarizer(result: RemoteResult): string;
+/**
+ * The summarizer registry: toolkit slug (or `prefix:*` glob) → {@link Summarizer}.
+ *
+ * Exact slugs win over globs, and globs win over the built-in default. Entries are
+ * added here (or at runtime via the exported map) to teach the bridge how to phrase
+ * a given product's results. The starter rows below are illustrative, declarative
+ * data — extend the table, don't fork the formatter.
+ */
+export declare const SUMMARIZERS: Map<string, Summarizer>;
+/**
+ * Summarize one operation's result in a single line.
+ *
+ * Selection is most-specific-first: an exact toolkit-slug entry, then a `prefix:*`
+ * glob whose prefix the slug starts with (longest prefix wins), then the built-in
+ * {@link defaultSummarizer}. The chosen summarizer is handed the raw result.
+ */
+export declare function summarizeResult(toolName: string, result: RemoteResult): string;

package/dist/types/connectors-sarvam/connect.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Connect to Sarvam AI via the official `uvx sarvam-mcp` stdio server.
+ *
+ * No OAuth — auth is the `SARVAM_API_KEY` env var. We spawn the subprocess
+ * with the SDK-backed {@link MCPClient} (which already supports stdio),
+ * list the remote tools, and project them into a runtime {@link ToolBox}
+ * via {@link mcpClientToToolBox} using `options.id` (default `"sarvam"`)
+ * as the tool-name prefix so two MCP servers can never collide.
+ */
+import type { ConnectSarvamMcpOptions, SarvamMcpConnection } from "./types.js";
+/**
+ * Open a Sarvam MCP stdio connection and return a ready-to-use toolbox + client.
+ */
+export declare function connectSarvamMcp(options: ConnectSarvamMcpOptions): Promise<SarvamMcpConnection>;

package/dist/types/connectors-sarvam/connectors-sarvam.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tests for {@link connectSarvamMcp}.
+ *
+ * A small `FakeMCPClient` stands in for the SDK-backed client. We use
+ * `vi.mock` to redirect the `MCPClient` import in `./connect.js` to a
+ * factory that returns our fake — no subprocess, no `uvx` download, no
+ * Sarvam network call, no monkey-patching of live modules. The mock
+ * captures every constructor invocation into a shared holder so the
+ * assertions can pin exactly what the connector passed to `new MCPClient`.
+ *
+ * Mirrors the structure of {@link ../connectors-zoho/connectors-zoho.test.ts}
+ * so the two connectors share one test idiom.
+ */
+export {};

package/dist/types/connectors-sarvam/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Public barrel for the Sarvam MCP connector.
+ *
+ *   - {@link connectSarvamMcp} — the high-level "give me a working toolbox"
+ *     entry point that takes a Sarvam API key (or env var) and spawns
+ *     `uvx sarvam-mcp` over stdio.
+ *   - {@link sarvamToolBoxFromClient} — the lower-level adapter for callers
+ *     who already hold a connected {@link MCPClient}.
+ *   - {@link ConnectSarvamMcpOptions} / {@link SarvamMcpConnection} — the
+ *     public types for those two entry points.
+ */
+export { connectSarvamMcp } from "./connect.js";
+export { sarvamToolBoxFromClient } from "./toolbox.js";
+export type { ConnectSarvamMcpOptions, SarvamMcpConnection } from "./types.js";

package/dist/types/connectors-sarvam/toolbox.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Thin re-export wrapper so power users can also import just the toolbox
+ * adapter without going through {@link connectSarvamMcp}.
+ *
+ * `sarvamToolBoxFromClient` is equivalent to
+ *   `mcpClientToToolBox(client, { namePrefix: options.id ?? "sarvam", ... })`
+ * — it just defaults the prefix to the Sarvam id.
+ */
+import type { McpToToolBoxOptions } from "../facade/mcp-core/toolbox-bridge.js";
+import type { MCPClient } from "../facade/mcp-core/client.js";
+import type { ToolBox } from "../runtime/contract/index.js";
+/**
+ * Wrap a connected {@link MCPClient} as a runtime {@link ToolBox} with a
+ * Sarvam-friendly prefix. Equivalent to
+ * `mcpClientToToolBox(client, { namePrefix: options.id ?? "sarvam", ... })`.
+ */
+export declare function sarvamToolBoxFromClient(client: MCPClient, options?: {
+    id?: string;
+} & Omit<McpToToolBoxOptions, "namePrefix">): Promise<ToolBox>;

package/dist/types/connectors-sarvam/types.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Public types for the Sarvam MCP integration.
+ *
+ * The Sarvam DX exposes an MCP server that runs as a stdio subprocess
+ * (`uvx sarvam-mcp`). Auth is a single dashboard-issued API key passed via
+ * the `SARVAM_API_KEY` environment variable. These types describe how a
+ * caller hands that key — plus a few cosmetic knobs — to
+ * {@link connectSarvamMcp} and gets back a runtime {@link ToolBox} ready to
+ * drop into `createAgent({ tools })`.
+ */
+import type { ToolBox } from "../runtime/contract/index.js";
+import type { MCPClient } from "../facade/mcp-core/client.js";
+/** Options for {@link connectSarvamMcp}. */
+export interface ConnectSarvamMcpOptions {
+    /** Sarvam dashboard API key. Falls back to process.env.SARVAM_API_KEY. */
+    readonly apiKey?: string;
+    /** Stable id used for tool-name prefixing (default: "sarvam"). */
+    readonly id?: string;
+    /** Override Sarvam API base URL. Falls back to SARVAM_API_BASE_URL env, then "https://api.sarvam.ai". */
+    readonly baseUrl?: string;
+    /** Override where the Sarvam MCP server writes audio/docs files. Falls back to SARVAM_MCP_BASE_PATH env, then "~/Desktop". */
+    readonly basePath?: string;
+    /** Subprocess command. Default: "uvx". */
+    readonly command?: string;
+    /** Subprocess args. Default: ["sarvam-mcp"]. */
+    readonly args?: readonly string[];
+    /** Extra env for the subprocess. SARVAM_API_KEY and the *_BASE_URL/_BASE_PATH vars above are merged on top. */
+    readonly env?: Readonly<Record<string, string>>;
+    /** Connect timeout in ms (default 60_000 — uvx may download on first run). */
+    readonly timeoutMs?: number;
+    /** Optional logger for diagnostics. */
+    readonly logger?: {
+        debug(msg: string): void;
+        error(msg: string, err?: unknown): void;
+    };
+}
+/** The handle returned by {@link connectSarvamMcp}. */
+export interface SarvamMcpConnection {
+    /** Stable id used for tool prefixing. */
+    readonly id: string;
+    /** Runtime ToolBox ready for `createAgent({ tools: sarvam.toolBox })`. */
+    readonly toolBox: ToolBox;
+    /** Names of every remote tool (already prefixed). */
+    readonly toolNames: readonly string[];
+    /** Underlying MCPClient (escape hatch). */
+    readonly client: MCPClient;
+    /** Disconnect and kill the spawned uvx child. Idempotent. */
+    close(): Promise<void>;
+}

package/dist/types/connectors-zoho/connect.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Connect to a Zoho MCP server.
+ *
+ * Validates the URL, builds an HTTP-backed {@link MCPClient} (Streamable HTTP by
+ * default, legacy SSE when `useSse: true`), wires an OAuth 2.1 + PKCE auth
+ * provider for the transport when `auth` is `"auto"` (default) or `"oauth"`,
+ * opens the connection, then bridges the remote tool catalog into a runtime
+ * {@link ToolBox} via {@link mcpClientToToolBox} using `options.id` (default
+ * `"zoho"`) as the tool-name prefix so two servers can never collide.
+ *
+ * On 401 from Zoho:
+ *   1. SDK discovers the auth server (RFC 9728 / 8414)
+ *   2. Browser opens for PKCE login
+ *   3. Local callback captures the code
+ *   4. `transport.finishAuth(code)` exchanges tokens
+ *   5. Reconnect with Bearer token
+ *
+ * Tokens persist to `~/.config/indusagi/credentials/mcp/<id>.json` (mode 0600).
+ */
+import type { ConnectZohoMcpOptions, ZohoMcpConnection } from "./types.js";
+/** Open a Zoho MCP connection and return a ready-to-use toolbox + client. */
+export declare function connectZohoMcp(options: ConnectZohoMcpOptions): Promise<ZohoMcpConnection>;

package/dist/types/connectors-zoho/connectors-zoho.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tests for {@link connectZohoMcp}.
+ *
+ * A small `FakeMCPClient` stands in for the SDK-backed client. We use
+ * `vi.mock` to redirect the `MCPClient` import in `./connect.js` to a
+ * factory that returns our fake — no network, no vendor SDK, no
+ * monkey-patching of live modules. The fake records every method call so
+ * assertions can pin exactly what the connector did.
+ */
+export {};

package/dist/types/connectors-zoho/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Public barrel for the Zoho MCP connector.
+ *
+ *   - {@link connectZohoMcp} — the high-level "give me a working toolbox"
+ *     entry point that takes a Zoho console URL.
+ *   - {@link zohoToolBoxFromClient} — the lower-level adapter for callers who
+ *     already hold a connected {@link MCPClient}.
+ *   - {@link ConnectZohoMcpOptions} / {@link ZohoMcpConnection} — the public
+ *     types for those two entry points.
+ */
+export { connectZohoMcp } from "./connect.js";
+export { zohoToolBoxFromClient } from "./toolbox.js";
+export type { ConnectZohoMcpOptions, ZohoMcpConnection } from "./types.js";

package/dist/types/connectors-zoho/toolbox.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Thin re-export wrapper so power users can also import just the toolbox
+ * adapter without going through {@link connectZohoMcp}.
+ *
+ * `zohoToolBoxFromClient` is equivalent to
+ *   `mcpClientToToolBox(client, { namePrefix: options.id ?? "zoho", ... })`
+ * — it just defaults the prefix to the Zoho id.
+ */
+import type { McpToToolBoxOptions } from "../facade/mcp-core/toolbox-bridge.js";
+import type { MCPClient } from "../facade/mcp-core/client.js";
+import type { ToolBox } from "../runtime/contract/index.js";
+/**
+ * Wrap a connected {@link MCPClient} as a runtime {@link ToolBox} with a
+ * Zoho-friendly prefix. Equivalent to
+ * `mcpClientToToolBox(client, { namePrefix: options.id ?? "zoho", ... })`.
+ */
+export declare function zohoToolBoxFromClient(client: MCPClient, options?: {
+    id?: string;
+} & Omit<McpToToolBoxOptions, "namePrefix">): Promise<ToolBox>;

package/dist/types/connectors-zoho/types.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Public types for the Zoho MCP integration.
+ *
+ * The Zoho DX exposes a remote MCP server URL from the Zoho developer console.
+ * These types describe how a caller hands that URL — plus a few cosmetic
+ * knobs — to {@link connectZohoMcp} and gets back a runtime
+ * {@link ToolBox} ready to drop into `createAgent({ tools })`.
+ */
+/** Options for {@link connectZohoMcp}. */
+export interface ConnectZohoMcpOptions {
+    /** The MCP server URL from Zoho console → Connect tab. */
+    readonly url: string;
+    /** Stable id used for tool-name prefixing (default: "zoho"). */
+    readonly id?: string;
+    /**
+     * Auth mode:
+     *  - "auto" (default): wire OAuth 2.1 + PKCE; let the SDK drive discovery and
+     *    token refresh on 401. Persists tokens to `~/.config/indusagi/credentials/mcp/<id>.json`.
+     *  - "oauth": same as "auto", explicit.
+     *  - "none": no client OAuth; pass the URL through as-is (Zoho may have
+     *    embedded a token, or you may have set a bearer via `headers`).
+     */
+    readonly auth?: "auto" | "oauth" | "none";
+    /** Optional static headers (e.g. Authorization). Use with care. */
+    readonly headers?: Readonly<Record<string, string>>;
+    /** Request timeout in ms (default 30_000). */
+    readonly timeoutMs?: number;
+    /** Use the legacy SSE transport instead of Streamable HTTP. Default: false. */
+    readonly useSse?: boolean;
+    /** Override the credentials directory (default: `~/.config/indusagi/credentials/mcp/`). */
+    readonly tokenStorePath?: string;
+    /** Override the OAuth redirect URI (default: `http://127.0.0.1:<random>/callback`). */
+    readonly redirectUrl?: string;
+    /** Open the browser for the OAuth round (default: true in TTY, false in CI). */
+    readonly openBrowser?: boolean;
+    /** OAuth scopes to request (default: server-advertised). */
+    readonly scopes?: readonly string[];
+    /** Optional logger for diagnostics. */
+    readonly logger?: {
+        debug(msg: string): void;
+        error(msg: string, err?: unknown): void;
+    };
+}
+/** The handle returned by {@link connectZohoMcp}. */
+export interface ZohoMcpConnection {
+    /** Stable id used for tool prefixing. */
+    readonly id: string;
+    /** Runtime ToolBox ready for `createAgent({ tools: zoho.toolBox })`. */
+    readonly toolBox: import("../runtime/contract/index.js").ToolBox;
+    /** Names of every remote tool (already prefixed). */
+    readonly toolNames: readonly string[];
+    /** Underlying MCPClient (escape hatch). */
+    readonly client: import("../facade/mcp-core/client.js").MCPClient;
+    /** Disconnect from the MCP server. Idempotent. */
+    close(): Promise<void>;
+}

package/dist/types/facade/agent.d.ts

@@ -0,0 +1 @@
+export * from "./bot/index";

package/dist/types/facade/ai.d.ts

@@ -0,0 +1 @@
+export * from "./ml/index";

package/dist/types/facade/bot/actions/bash.d.ts

@@ -0,0 +1,71 @@
+import type { AgentTool } from "../types.js";
+import type { HookRunner } from "./kit/hook-runner.js";
+import { type SandboxConfig } from "./sandbox-backend.js";
+import { type TruncationResult } from "./truncate.js";
+export interface BashSecurityConfig {
+    /** Patterns that, when matched, stop a command from running. */
+    blockedPatterns?: RegExp[];
+}
+declare const bashSchema: import("@sinclair/typebox").TObject<{
+    command: import("@sinclair/typebox").TString;
+    timeout: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export interface BashToolDetails {
+    truncation?: TruncationResult;
+    fullOutputPath?: string;
+}
+/**
+ * Pluggable execution backend for the bash tool. Provide a custom implementation
+ * to dispatch commands somewhere other than the local shell, for instance to a
+ * remote host over a transport layer.
+ */
+export interface BashOperations {
+    /**
+     * Execute a command, relaying its output back through a callback as it streams in.
+     * @param command - The command line to execute
+     * @param cwd - Working directory for the command
+     * @param options - Streaming callback, cancellation signal, timeout, and env overrides
+     * @returns A promise resolving to the exit code, or null if the process was terminated
+     */
+    exec: (command: string, cwd: string, options: {
+        onData: (data: Buffer) => void;
+        signal?: AbortSignal;
+        timeout?: number;
+        env?: NodeJS.ProcessEnv;
+    }) => Promise<{
+        exitCode: number | null;
+    }>;
+}
+export interface BashToolOptions {
+    /** Backend hook for running commands. When omitted, the local shell is used. */
+    operations?: BashOperations;
+    /** Text glued to the front of every command (e.g. "shopt -s expand_aliases" to enable aliases). */
+    commandPrefix?: string;
+    /** Dispatcher consulted for the shell.env hook so callers can inject env vars. */
+    hookRunner?: HookRunner;
+    /** Settings that decide which commands are allowed to run. */
+    security?: BashSecurityConfig;
+    /**
+     * OPT-IN OS sandbox. OFF by default: when omitted or `enabled` is false the
+     * bash tool spawns exactly as before. When enabled, each command is wrapped
+     * in the platform's OS sandbox (macOS `sandbox-exec`, Linux `bwrap`); if no
+     * sandbox tool is available the command runs un-sandboxed and a note is
+     * recorded via `onSandboxNote` rather than silently claiming sandboxing.
+     */
+    sandbox?: SandboxConfig;
+    /** Receives an honest note describing whether the sandbox was applied or skipped. */
+    onSandboxNote?: (note: string) => void;
+    /** Optional log that collects the commands as they are issued. */
+    commandHistory?: string[];
+    /** Time budget, in seconds, applied when the model omits `timeout`. Defaults to 120s. */
+    defaultTimeoutSeconds?: number;
+    /** Hard ceiling, in seconds, that any supplied `timeout` is clamped to. Defaults to 600s (and is never lower than the default). */
+    maxTimeoutSeconds?: number;
+}
+export declare function createBashTool(cwd: string, options?: BashToolOptions): AgentTool<typeof bashSchema>;
+/** Ready-made bash tool bound to the process working directory. */
+export declare const bashTool: AgentTool<import("@sinclair/typebox").TObject<{
+    command: import("@sinclair/typebox").TString;
+    timeout: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, any>;
+export {};

package/dist/types/facade/bot/actions/bash.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/facade/bot/actions/checkpoint.d.ts

@@ -0,0 +1,49 @@
+/**
+ * File-checkpoint hook for the WIRED facade tool layer.
+ *
+ * This is the framework half of the rewind feature. The product (the coding
+ * agent) constructs a `CheckpointStore`, exposes a small duck-typed
+ * {@link CheckpointHandle} on the shared `ctx.framework` bag under the literal
+ * key `'checkpoint'`, and passes it into the `write` / `edit` factories — the
+ * same place the read-before-edit gate's `readState` handle is wired. When a
+ * handle is present, every mutating file tool captures the file's pre-mutation
+ * on-disk content EXACTLY ONCE per mutated path, so a later rewind can roll the
+ * working tree back to that snapshot.
+ *
+ * Like the read-edit gate, the whole mechanism is *additive*: with no handle
+ * present every helper here is a no-op and the tools behave exactly as they did
+ * before. The handle is duck-typed so the host and these factories agree on
+ * shape without a cross-package type import.
+ */
+/**
+ * Duck-typed sink the host injects to receive pre-mutation snapshots.
+ *
+ * `record` is called once per mutated path, before the write lands, with the
+ * file's OLD on-disk content — or `null` when the file did not exist on disk
+ * before this mutation (so a rewind that visits this snapshot knows to DELETE
+ * the file rather than restore stale bytes).
+ */
+export interface CheckpointHandle {
+    /**
+     * Capture the pre-mutation state of `absPath`.
+     *
+     * @param absPath  Absolute path of the file about to be written.
+     * @param previous The file's content before this mutation, or `null` if the
+     *                 file did not exist on disk beforehand.
+     */
+    record(absPath: string, previous: string | null): void;
+}
+/**
+ * Read the CURRENT on-disk content of `absPath` and hand it to the checkpoint
+ * handle, capturing the PRE-mutation state.
+ *
+ * This MUST be invoked synchronously-ordered immediately before the write so the
+ * captured snapshot is the OLD content (no read/write race). When the file does
+ * not exist on disk, `null` is recorded so a rewind knows to delete it.
+ *
+ * No-op when no handle is present. A read/stat failure that is NOT a plain
+ * "missing file" is swallowed: checkpointing is best-effort and must never mask
+ * the real operation's outcome. (A genuine ENOENT is reported as `null`, the
+ * meaningful "file absent" snapshot.)
+ */
+export declare function recordCheckpoint(handle: CheckpointHandle | undefined, absPath: string): void;

package/dist/types/facade/bot/actions/checkpoint.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/facade/bot/actions/composio/accounts.d.ts

@@ -0,0 +1,22 @@
+import type { AgentTool } from "../../types.js";
+import { ComposioService } from "./client.js";
+import type { ComposioToolFactoryOptions } from "./types.js";
+declare const composioAccountsSchema: import("@sinclair/typebox").TObject<{
+    toolkits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    statuses: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    cursor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    authConfigIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+}>;
+export type ComposioAccountsToolDetails = Awaited<ReturnType<ComposioService["listAccounts"]>> & {
+    userId: string;
+};
+export declare function createComposioAccountsTool(options?: ComposioToolFactoryOptions): AgentTool<typeof composioAccountsSchema, ComposioAccountsToolDetails>;
+export declare const composioAccountsTool: AgentTool<import("@sinclair/typebox").TObject<{
+    toolkits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    statuses: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    cursor: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    authConfigIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+}>, ComposioAccountsToolDetails>;
+export {};

package/dist/types/facade/bot/actions/composio/client.d.ts

@@ -0,0 +1,39 @@
+import type { ConnectedAccountListParams, ConnectedAccountListResponse, ToolListParams, ToolkitConnectionsDetails, ToolRouterSessionSearchResponse } from "@composio/core";
+import type { ComposioAgentTool, ComposioAgentToolsOptions, ComposioBaseOptions, ComposioConnectResult, ComposioExecuteResult, ComposioRawTool, ComposioToolListResult } from "./types.js";
+export declare class ComposioService {
+    private readonly options;
+    private readonly provider;
+    private clientPromise;
+    private readonly rawToolCache;
+    private readonly sessionCache;
+    constructor(options?: ComposioBaseOptions);
+    resolveUserId(): Promise<string>;
+    private resolveApiKey;
+    private getClient;
+    getRawToolBySlug(slug: string): Promise<ComposioRawTool>;
+    listRawTools(filters: ToolListParams): Promise<ComposioToolListResult>;
+    private resolveToolListFilters;
+    private resolveSessionSelection;
+    private getSession;
+    listToolkits(input: {
+        toolkits?: string[];
+        search?: string;
+        limit?: number;
+        nextCursor?: string;
+        isConnected?: boolean;
+    }): Promise<ToolkitConnectionsDetails>;
+    searchTools(query: string, toolkits?: string[]): Promise<ToolRouterSessionSearchResponse>;
+    createAgentTools(options: ComposioAgentToolsOptions): Promise<ComposioAgentTool[]>;
+    executeTool(options: ComposioAgentToolsOptions & {
+        toolSlug: string;
+        arguments?: Record<string, unknown>;
+    }): Promise<ComposioExecuteResult>;
+    listAccounts(filters?: ConnectedAccountListParams): Promise<ConnectedAccountListResponse>;
+    connectAccount(options: {
+        toolkit?: string;
+        connectedAccountId?: string;
+        authConfigId?: string;
+        callbackUrl?: string;
+    }): Promise<ComposioConnectResult>;
+}
+export declare function createComposioAgentTools(options: ComposioAgentToolsOptions): Promise<ComposioAgentTool[]>;

package/dist/types/facade/bot/actions/composio/connect.d.ts

@@ -0,0 +1,19 @@
+import type { AgentTool } from "../../types.js";
+import type { ComposioConnectResult, ComposioToolFactoryOptions } from "./types.js";
+declare const composioConnectSchema: import("@sinclair/typebox").TObject<{
+    toolkit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    connectedAccountId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    authConfigId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    callbackUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export interface ComposioConnectToolDetails extends ComposioConnectResult {
+    userId: string;
+}
+export declare function createComposioConnectTool(options?: ComposioToolFactoryOptions): AgentTool<typeof composioConnectSchema, ComposioConnectToolDetails>;
+export declare const composioConnectTool: AgentTool<import("@sinclair/typebox").TObject<{
+    toolkit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    connectedAccountId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    authConfigId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    callbackUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>, ComposioConnectToolDetails>;
+export {};

package/dist/types/facade/bot/actions/composio/enable.d.ts

@@ -0,0 +1,25 @@
+import type { AgentTool } from "../../types.js";
+import type { ComposioToolFactoryOptions, ComposioToolMetadata } from "./types.js";
+declare const composioEnableSchema: import("@sinclair/typebox").TObject<{
+    toolkits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    toolSlugs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    authConfigs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    connectedAccounts: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    authConfigId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    connectedAccountId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export interface ComposioEnableToolDetails {
+    userId: string;
+    enabledTools: ComposioToolMetadata[];
+    activationApplied: boolean;
+}
+export declare function createComposioEnableTool(options?: ComposioToolFactoryOptions): AgentTool<typeof composioEnableSchema, ComposioEnableToolDetails>;
+export declare const composioEnableTool: AgentTool<import("@sinclair/typebox").TObject<{
+    toolkits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    toolSlugs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    authConfigs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    connectedAccounts: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    authConfigId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    connectedAccountId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>, ComposioEnableToolDetails>;
+export {};

package/dist/types/facade/bot/actions/composio/execute.d.ts

@@ -0,0 +1,26 @@
+import type { AgentTool } from "../../types.js";
+import type { ComposioExecuteResult, ComposioToolFactoryOptions } from "./types.js";
+declare const composioExecuteSchema: import("@sinclair/typebox").TObject<{
+    toolSlug: import("@sinclair/typebox").TString;
+    arguments: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>>;
+    toolkits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    authConfigs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    connectedAccounts: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    authConfigId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    connectedAccountId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export interface ComposioExecuteToolDetails extends ComposioExecuteResult {
+    userId: string;
+    toolSlug: string;
+}
+export declare function createComposioExecuteTool(options?: ComposioToolFactoryOptions): AgentTool<typeof composioExecuteSchema, ComposioExecuteToolDetails>;
+export declare const composioExecuteTool: AgentTool<import("@sinclair/typebox").TObject<{
+    toolSlug: import("@sinclair/typebox").TString;
+    arguments: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>>;
+    toolkits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+    authConfigs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    connectedAccounts: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    authConfigId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    connectedAccountId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>, ComposioExecuteToolDetails>;
+export {};

package/dist/types/facade/bot/actions/composio/helpers.d.ts

@@ -0,0 +1,16 @@
+import type { ConnectedAccountListResponse, Tool as ComposioRawTool, ToolRouterSessionSearchResponse, ToolkitConnectionsDetails } from "@composio/core";
+import type { ComposioConnectResult, ComposioExecuteResult, ComposioToolMetadata } from "./types.js";
+export declare const DEFAULT_COMPOSIO_USER_ID = "default";
+export declare function buildComposioToolName(slug: string): string;
+export declare function buildComposioToolDescription(tool: ComposioRawTool): string;
+export declare function extractToolMetadata(tool: Pick<ComposioRawTool, "slug" | "name" | "toolkit" | "isNoAuth" | "version">): ComposioToolMetadata;
+export declare function safeJsonStringify(value: unknown): string;
+export declare function formatExecutionPayload(data: unknown, fallback?: string): string;
+export declare function formatExecuteResult(result: ComposioExecuteResult): string;
+export declare function formatToolkitList(toolkits: ToolkitConnectionsDetails): string;
+export declare function formatRawToolList(items: ComposioRawTool[]): string;
+export declare function formatSearchResults(result: ToolRouterSessionSearchResponse): string;
+export declare function formatConnectedAccounts(accounts: ConnectedAccountListResponse): string;
+export declare function formatConnectResult(result: ComposioConnectResult): string;
+export declare function stableStringify(value: unknown): string;
+export declare function uniqueStrings(values: readonly string[] | undefined): string[];

package/dist/types/facade/bot/actions/composio/index.d.ts

@@ -0,0 +1,9 @@
+export { ComposioService, createComposioAgentTools } from "./client.js";
+export { IndusagiComposioProvider } from "./provider.js";
+export { createComposioToolkitsTool, composioToolkitsTool, type ComposioToolkitsToolDetails, } from "./toolkits.js";
+export { createComposioToolsTool, composioToolsTool, type ComposioToolsToolDetails, } from "./tools.js";
+export { createComposioConnectTool, composioConnectTool, type ComposioConnectToolDetails, } from "./connect.js";
+export { createComposioExecuteTool, composioExecuteTool, type ComposioExecuteToolDetails, } from "./execute.js";
+export { createComposioEnableTool, composioEnableTool, type ComposioEnableToolDetails, } from "./enable.js";
+export { createComposioAccountsTool, composioAccountsTool, type ComposioAccountsToolDetails, } from "./accounts.js";
+export type { ComposioAgentTool, ComposioAgentToolsOptions, ComposioBaseOptions, ComposioClientFactory, ComposioConnectResult, ComposioEnableHandler, ComposioExecuteResult, ComposioServiceLike, ComposioToolExecutionDetails, ComposioToolFactoryOptions, ComposioToolListResult, ComposioToolMetadata, ComposioToolSelection, } from "./types.js";

package/dist/types/facade/bot/actions/composio/provider.d.ts

@@ -0,0 +1,8 @@
+import type { Tool as ComposioRawTool, ToolExecuteResponse } from "@composio/core";
+import { BaseAgenticProvider } from "@composio/core";
+import type { ComposioAgentTool } from "./types.js";
+export declare class IndusagiComposioProvider extends BaseAgenticProvider<ComposioAgentTool[], ComposioAgentTool, unknown> {
+    readonly name = "indusagi-framework";
+    wrapTool(tool: ComposioRawTool, executeTool: (toolSlug: string, input: Record<string, unknown>) => Promise<ToolExecuteResponse>): ComposioAgentTool;
+    wrapTools(tools: ComposioRawTool[], executeTool: (toolSlug: string, input: Record<string, unknown>) => Promise<ToolExecuteResponse>): ComposioAgentTool[];
+}