qlogicagent 0.5.2 → 0.5.3

package/dist/types/skills/tools/shell/shell-provider.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Discriminated shell type identifier.
+ */
+export type ShellType = "bash" | "powershell";
+/**
+ * Options passed to `buildExecCommand`.
+ */
+export interface BuildCommandOpts {
+    /** Unique command invocation ID (for CWD temp-file naming). */
+    id: string;
+    /** If set, sandbox TMPDIR root. */
+    sandboxTmpDir?: string;
+    /** Whether sandbox mode is active. */
+    useSandbox: boolean;
+}
+/**
+ * Result of `buildExecCommand` — the final command string
+ * and the path where the shell will write its post-command CWD.
+ */
+export interface BuiltCommand {
+    /** Fully-wrapped command string ready for spawn. */
+    commandString: string;
+    /**
+     * Temp file path where the shell writes its post-command CWD.
+     * Used by the host to track `cd` across invocations.
+     * undefined if CWD tracking is not supported / not needed.
+     */
+    cwdFilePath?: string;
+}
+/**
+ * Runtime-agnostic shell provider.
+ *
+ * Hosts (Gateway / Desktop / Hub) create a provider once, then
+ * use it for every `exec()` call. The tool itself never
+ * `spawn()`s — the host does, using args from this provider.
+ */
+export interface ShellProvider {
+    /** Shell type discriminator. */
+    readonly type: ShellType;
+    /** Absolute path to the shell binary. */
+    readonly shellPath: string;
+    /**
+     * Whether `spawn()` should use `detached: true`.
+     * Bash: true (allows job control / cleanup).
+     * PowerShell: false (no POSIX process groups on Windows).
+     */
+    readonly detached: boolean;
+    /**
+     * Wrap a raw user command into a full shell command string.
+     * Handles:
+     *   - Environment snapshots / session env sourcing (bash)
+     *   - UTF-16LE EncodedCommand wrapping (PowerShell)
+     *   - CWD tracking (`pwd -P > file` / `Get-Location | Out-File`)
+     *   - stdin redirect for interactive commands (bash)
+     */
+    buildExecCommand(command: string, opts: BuildCommandOpts): Promise<BuiltCommand>;
+    /**
+     * Return the argv array for `child_process.spawn()`.
+     * E.g. bash → `['-c', commandString]`
+     *      PS   → `['-NoProfile', '-NonInteractive', '-Command', cmd]`
+     */
+    getSpawnArgs(commandString: string): string[];
+    /**
+     * Return extra environment variables to merge into spawn env.
+     * E.g. `{ SHELL: '/bin/bash', GIT_EDITOR: 'true', CLAUDECODE: '1' }`
+     */
+    getEnvironmentOverrides(command: string): Promise<Record<string, string>>;
+}
+/**
+ * Check if PowerShell tool mode should be enabled.
+ * Mirrors cc's `isPowerShellToolEnabled()`.
+ *
+ * On Windows: enabled when `QLOGICAGENT_USE_POWERSHELL` is truthy.
+ * On non-Windows: always false.
+ */
+export declare function isPowerShellToolEnabled(): boolean;
+/**
+ * Default shell type for the current platform.
+ */
+export declare function getDefaultShellType(): ShellType;
+/**
+ * Generate a short random hex ID for CWD temp file naming.
+ * Matches cc's `Math.floor(Math.random() * 0x10000).toString(16)`.
+ */
+export declare function generateCommandId(): string;

package/dist/types/skills/tools/shell/task-output.d.ts

@@ -0,0 +1,45 @@
+/** Progress callback — matches cc's signature. */
+export type ProgressCallback = (lastLines: string, allLines: string, totalLines: number, totalBytes: number, isIncomplete: boolean) => void;
+/** Max output file on disk (background tasks). */
+export declare const MAX_TASK_OUTPUT_BYTES: number;
+export declare const MAX_TASK_OUTPUT_BYTES_DISPLAY = "5GB";
+/** Lazily generate session-scoped task output directory. */
+export declare function getTaskOutputDir(): string;
+/** Set the task output directory (for embedding hosts to override). */
+export declare function setTaskOutputDir(dir: string): void;
+export declare function getTaskOutputPath(taskId: string): string;
+export declare function generateTaskId(prefix?: string): string;
+/**
+ * Single source of truth for a shell command's output.
+ * Ported from cc's TaskOutput.
+ *
+ * For bash commands (file mode): both stdout/stderr go to file fd.
+ * For hooks (pipe mode): data flows through writeStdout/writeStderr.
+ */
+export declare class TaskOutput {
+    #private;
+    readonly taskId: string;
+    readonly path: string;
+    readonly stdoutToFile: boolean;
+    constructor(taskId: string, onProgress: ProgressCallback | null, stdoutToFile?: boolean, maxMemory?: number);
+    /** Write stdout data (pipe mode). */
+    writeStdout(data: string): void;
+    /** Write stderr data (pipe mode). */
+    writeStderr(data: string): void;
+    /** Get captured stdout. For file mode, reads from disk. */
+    getStdout(): Promise<string>;
+    /** Get captured stderr. In file mode stderr is interleaved with stdout. */
+    getStderr(): string;
+    get outputFileSize(): number;
+    /**
+     * Whether the output file content is fully contained in getStdout().
+     * If true, the file can be deleted.
+     */
+    get outputFileRedundant(): boolean;
+    /** Write in-memory buffer to disk file. */
+    spillToDisk(): void;
+    /** Delete the output file on disk. */
+    deleteOutputFile(): Promise<void>;
+    /** Clean up all resources. */
+    clear(): void;
+}

package/dist/types/skills/tools/skill-invoke-tool.d.ts

@@ -0,0 +1,46 @@
+import type { PortableTool } from "../portable-tool.js";
+import type { WorkspaceSkill } from "../skill-types.js";
+export declare const SKILL_TOOL_NAME: "skill_invoke";
+export interface SkillInvokeParams {
+    skill: string;
+    args?: string;
+}
+export declare const SKILL_INVOKE_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly skill: {
+            readonly type: "string";
+            readonly description: "Name of the skill to invoke. Use skill_list to see available skills.";
+        };
+        readonly args: {
+            readonly type: "string";
+            readonly description: string;
+        };
+    };
+    readonly required: readonly ["skill"];
+};
+export interface SkillToolDeps {
+    /**
+     * Get all available skills (Layer 0 metadata).
+     * Returns name + description pairs for tool manifest enrichment.
+     */
+    listSkills(): WorkspaceSkill[];
+    /**
+     * Read skill content (Layer 1 instructions).
+     * Returns the full SKILL.md content for the named skill.
+     * Returns null if skill not found.
+     */
+    readSkillContent(name: string): Promise<string | null>;
+    /**
+     * Execute the skill instructions as a sub-turn.
+     * The implementation should:
+     *   1. Build system prompt from SKILL.md content
+     *   2. Run a sub-turn (sidechain) with skill instructions
+     *   3. Return the sub-turn's final response
+     *
+     * If not provided, the skill content is returned directly
+     * (the LLM can then follow the instructions in context).
+     */
+    executeSkillSubturn?(skillName: string, skillContent: string, userArgs: string | undefined, signal?: AbortSignal): Promise<string>;
+}
+export declare function createSkillTool(deps: SkillToolDeps): PortableTool<SkillInvokeParams>;

package/dist/types/skills/tools/skill-list-tool.d.ts

@@ -0,0 +1,33 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const SKILL_LIST_TOOL_NAME: "skill_list";
+export interface SkillListToolParams {
+    category?: string;
+}
+export declare const SKILL_LIST_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly category: {
+            readonly type: "string";
+            readonly description: "Filter skills by category (e.g. 'devops', 'mlops'). Omit to list all.";
+        };
+    };
+    readonly required: readonly [];
+};
+export interface SkillListItem {
+    name: string;
+    description: string;
+    version?: string;
+    category?: string;
+}
+export interface SkillListOutput {
+    skills: SkillListItem[];
+    categories: string[];
+}
+/**
+ * Host-provided skill registry for listing.
+ */
+export interface SkillListToolDeps {
+    /** List all available skills, optionally filtered by category. */
+    listSkills(category?: string): Promise<SkillListOutput>;
+}
+export declare function createSkillListTool(deps: SkillListToolDeps): PortableTool<SkillListToolParams>;

package/dist/types/skills/tools/skill-manage-tool.d.ts

@@ -0,0 +1,73 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const SKILL_MANAGE_TOOL_NAME: "skill_manage";
+export type SkillManageAction = "create" | "edit" | "patch" | "delete" | "write_file" | "remove_file";
+export interface SkillManageToolParams {
+    action: SkillManageAction;
+    name: string;
+    content?: string;
+    category?: string;
+    filePath?: string;
+    fileContent?: string;
+    oldString?: string;
+    newString?: string;
+}
+export declare const SKILL_MANAGE_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly action: {
+            readonly type: "string";
+            readonly enum: readonly ["create", "edit", "patch", "delete", "write_file", "remove_file"];
+            readonly description: string;
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly description: "Skill name (lowercase, max 64 chars, kebab-case: letters, digits, hyphens).";
+        };
+        readonly content: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly category: {
+            readonly type: "string";
+            readonly description: "Category/domain (e.g. 'devops', 'mlops'). Used by create to organize skills.";
+        };
+        readonly filePath: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly fileContent: {
+            readonly type: "string";
+            readonly description: "Content for write_file action. Max 1 MiB.";
+        };
+        readonly oldString: {
+            readonly type: "string";
+            readonly description: "Text to find for patch action (must match uniquely in SKILL.md).";
+        };
+        readonly newString: {
+            readonly type: "string";
+            readonly description: "Replacement text for patch action (can be empty to delete).";
+        };
+    };
+    readonly required: readonly ["action", "name"];
+};
+export interface SkillManageResult {
+    success: boolean;
+    message: string;
+    path?: string;
+}
+/**
+ * Host-provided skill management backend.
+ */
+export interface SkillManageToolDeps {
+    /**
+     * Execute a skill management action.
+     * The host handles file system operations, validation, and security scanning.
+     */
+    manageSkill(params: SkillManageToolParams): Promise<SkillManageResult>;
+    /**
+     * Validate skill name format.
+     * If not provided, tool uses built-in validation.
+     */
+    validateName?(name: string): string | null;
+}
+export declare function createSkillManageTool(deps: SkillManageToolDeps): PortableTool<SkillManageToolParams>;

package/dist/types/skills/tools/skill-view-tool.d.ts

@@ -0,0 +1,37 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const SKILL_VIEW_TOOL_NAME: "skill_view";
+export interface SkillViewToolParams {
+    name: string;
+    filePath?: string;
+}
+export declare const SKILL_VIEW_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly description: "Skill name to view (e.g. 'code-review', 'deploy-ecs').";
+        };
+        readonly filePath: {
+            readonly type: "string";
+            readonly description: string;
+        };
+    };
+    readonly required: readonly ["name"];
+};
+export interface SkillViewOutput {
+    name: string;
+    content: string;
+    referenceFiles?: string[];
+    tags?: string[];
+}
+/**
+ * Host-provided skill viewer.
+ */
+export interface SkillViewToolDeps {
+    /**
+     * Read skill content. Returns the main SKILL.md or a specific file.
+     * Returns null if skill not found.
+     */
+    viewSkill(name: string, filePath?: string): Promise<SkillViewOutput | null>;
+}
+export declare function createSkillViewTool(deps: SkillViewToolDeps): PortableTool<SkillViewToolParams>;

package/dist/types/skills/tools/sleep-tool.d.ts

@@ -0,0 +1,49 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const SLEEP_TOOL_NAME: "sleep";
+export interface SleepToolParams {
+    /** Duration to sleep in seconds (1–3600). */
+    duration: number;
+    /** Reason for sleeping — helps the runtime decide whether to interrupt. */
+    reason?: string;
+}
+export declare const SLEEP_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly duration: {
+            readonly type: "number";
+            readonly description: "Duration to sleep in seconds (1–3600). Prefer short sleeps (10–60s) to stay responsive.";
+            readonly minimum: 1;
+            readonly maximum: 3600;
+        };
+        readonly reason: {
+            readonly type: "string";
+            readonly description: string;
+        };
+    };
+    readonly required: readonly ["duration"];
+};
+/** The result returned after a sleep completes or is interrupted. */
+export interface SleepResult {
+    /** Actual time slept in seconds (may be less if interrupted). */
+    sleptSeconds: number;
+    /** Whether the sleep was interrupted before completing. */
+    interrupted: boolean;
+    /** The event that caused the interruption (undefined if not interrupted). */
+    interruptReason?: string;
+}
+/**
+ * Runtime dependencies injected by the host.
+ *
+ * The sleep mechanism is host-provided — the tool itself does NOT call
+ * setTimeout. The host decides how to implement the wait (timer, event loop
+ * integration, tick prompt scheduling, etc.).
+ */
+export interface SleepToolDeps {
+    /**
+     * Perform the actual sleep. Must resolve after `durationMs` or when
+     * interrupted (whichever is first). The AbortSignal fires if the user
+     * or the system requests an interrupt.
+     */
+    sleep(durationMs: number, signal: AbortSignal): Promise<SleepResult>;
+}
+export declare function createSleepTool(deps: SleepToolDeps): PortableTool<SleepToolParams>;

package/dist/types/skills/tools/structured-output-tool.d.ts

@@ -0,0 +1,116 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const STRUCTURED_OUTPUT_TOOL_NAME: "structured_output";
+/** Maximum content size for structured output results. */
+export declare const STRUCTURED_OUTPUT_MAX_CHARS = 100000;
+export interface StructuredOutputToolParams {
+    /** The structured data to return. Must conform to the session's output schema. */
+    data: Record<string, unknown>;
+}
+/**
+ * Base schema — accepts any object.
+ * When used with createConfiguredStructuredOutputTool, the host overrides
+ * this with the actual JSON Schema from `response_format.json_schema`.
+ */
+export declare const STRUCTURED_OUTPUT_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly data: {
+            readonly type: "object";
+            readonly description: string;
+            readonly additionalProperties: true;
+        };
+    };
+    readonly required: readonly ["data"];
+};
+/** Schema validation error detail. */
+export interface SchemaValidationError {
+    path: string;
+    message: string;
+    keyword?: string;
+}
+/** Result of structured output validation. */
+export interface StructuredOutputResult {
+    valid: boolean;
+    errors?: SchemaValidationError[];
+}
+/**
+ * Whether the structured output tool should be enabled for this session.
+ * CC equivalent: `isSyntheticOutputToolEnabled`.
+ */
+export declare function isStructuredOutputEnabled(opts: {
+    isNonInteractiveSession: boolean;
+}): boolean;
+/**
+ * Runtime dependencies injected by the host.
+ *
+ * The host provides:
+ * 1. The JSON Schema to validate against (from session config)
+ * 2. A validator function (host may use Ajv, Zod, or any validator)
+ * 3. An output sink to deliver the validated data
+ *
+ * The tool is only available in non-interactive (SDK/API) sessions
+ * where a `response_format.json_schema` has been specified.
+ */
+export interface StructuredOutputToolDeps {
+    /**
+     * Get the JSON Schema that the output must conform to.
+     * Returns undefined if no schema is configured (tool should not be registered).
+     */
+    getOutputSchema(): Record<string, unknown> | undefined;
+    /**
+     * Validate data against the output schema.
+     * Returns { valid: true } or { valid: false, errors: [...] }.
+     */
+    validateOutput(data: Record<string, unknown>): StructuredOutputResult;
+    /**
+     * Deliver the validated output to the caller.
+     * Called only after successful validation.
+     */
+    deliverOutput(data: Record<string, unknown>): Promise<void>;
+}
+/**
+ * Create the base structured output tool with DI-based validation.
+ * This is the standard factory for runtime integration.
+ */
+export declare function createStructuredOutputTool(deps: StructuredOutputToolDeps): PortableTool<StructuredOutputToolParams>;
+/**
+ * Result of creating a configured structured output tool.
+ * Success: { tool } — ready-to-use tool with compiled schema.
+ * Failure: { error } — schema was invalid.
+ */
+export type ConfiguredToolResult = {
+    tool: PortableTool<StructuredOutputToolParams>;
+} | {
+    error: string;
+};
+/**
+ * Host-provided schema compilation interface.
+ * Allows the host to use any validator (Ajv, Zod, custom).
+ */
+export interface SchemaCompiler {
+    /**
+     * Validate that the schema itself is a valid JSON Schema.
+     * Returns null if valid, or an error message string if invalid.
+     */
+    validateSchema(schema: Record<string, unknown>): string | null;
+    /**
+     * Compile the schema into a reusable validator function.
+     * Returns a function that validates data and returns StructuredOutputResult.
+     */
+    compile(schema: Record<string, unknown>): (data: Record<string, unknown>) => StructuredOutputResult;
+}
+/**
+ * Create a StructuredOutputTool configured with a specific JSON Schema.
+ * Mirrors CC's `createSyntheticOutputTool(jsonSchema)`.
+ *
+ * Features:
+ * - Validates the schema itself at creation time
+ * - Compiles the validator for reuse (cached via WeakMap)
+ * - Overrides the tool's `parameters` with the provided schema (dynamic input)
+ * - Returns { tool } on success or { error } if schema is invalid
+ *
+ * @param jsonSchema  The JSON Schema to validate output against.
+ * @param compiler    Schema compiler/validator provided by the host.
+ * @param deliver     Output delivery function (called after successful validation).
+ */
+export declare function createConfiguredStructuredOutputTool(jsonSchema: Record<string, unknown>, compiler: SchemaCompiler, deliver: (data: Record<string, unknown>) => Promise<void>): ConfiguredToolResult;

package/dist/types/skills/tools/task-tool.d.ts

@@ -0,0 +1,104 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const TASK_TOOL_NAME: "task";
+export type TaskAction = "create" | "get" | "list" | "output" | "stop";
+export type TaskStatus = "pending" | "running" | "completed" | "failed" | "stopped";
+export interface TaskToolParams {
+    action: TaskAction;
+    /** Task ID (required for get/output/stop) */
+    taskId?: string;
+    /** Task prompt (required for create) */
+    prompt?: string;
+    /** Short description (3-7 words, for create) */
+    description?: string;
+    /** Allowed tools for the background agent */
+    allowedTools?: string[];
+    /** Working directory for the task */
+    cwd?: string;
+    /** Model override for the task agent */
+    model?: string;
+    /** Max output lines to return (for output action, default 100) */
+    maxLines?: number;
+}
+export declare const TASK_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly action: {
+            readonly type: "string";
+            readonly enum: readonly ["create", "get", "list", "output", "stop"];
+            readonly description: string;
+        };
+        readonly taskId: {
+            readonly type: "string";
+            readonly description: "Task ID. Required for get/output/stop.";
+        };
+        readonly prompt: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly description: "Short (3-7 word) description of the task. Used for tracking and display.";
+        };
+        readonly allowedTools: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "Restrict background agent to only these tools. If omitted, inherits parent's tools.";
+        };
+        readonly cwd: {
+            readonly type: "string";
+            readonly description: "Working directory for the background task (absolute path).";
+        };
+        readonly model: {
+            readonly type: "string";
+            readonly description: "Model override for the task agent (e.g. 'sonnet', 'opus').";
+        };
+        readonly maxLines: {
+            readonly type: "number";
+            readonly description: "Max output lines to return for the 'output' action (default: 100).";
+            readonly minimum: 1;
+            readonly maximum: 2000;
+        };
+    };
+    readonly required: readonly ["action"];
+};
+export interface TaskInfo {
+    taskId: string;
+    status: TaskStatus;
+    description?: string;
+    prompt?: string;
+    createdAt: number;
+    completedAt?: number;
+    result?: string;
+    error?: string;
+}
+export interface TaskResult {
+    success: boolean;
+    task?: TaskInfo;
+    tasks?: TaskInfo[];
+    output?: string;
+    error?: string;
+}
+/** Host-provided task management backend. */
+export interface TaskToolDeps {
+    /** Create a new background agent task. Returns the created task info. */
+    createTask(params: {
+        prompt: string;
+        description?: string;
+        allowedTools?: string[];
+        cwd?: string;
+        model?: string;
+    }): Promise<TaskInfo>;
+    /** Get a task by ID. Returns null if not found. */
+    getTask(taskId: string): Promise<TaskInfo | null>;
+    /** List all tasks (optionally filtered by status). */
+    listTasks(filter?: {
+        status?: TaskStatus;
+    }): Promise<TaskInfo[]>;
+    /** Get output/logs from a task. */
+    getTaskOutput(taskId: string, maxLines?: number): Promise<string>;
+    /** Stop a running task. Returns true if stopped successfully. */
+    stopTask(taskId: string): Promise<boolean>;
+}
+export declare function createTaskTool(deps: TaskToolDeps): PortableTool<TaskToolParams>;

package/dist/types/skills/tools/team-tool.d.ts

@@ -0,0 +1,89 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const TEAM_TOOL_NAME: "team";
+export type TeamAction = "create" | "delete" | "list" | "status";
+export interface TeamMember {
+    name: string;
+    role: string;
+    tools?: string[];
+}
+export interface TeamToolParams {
+    action: TeamAction;
+    /** Team name (required for create/delete) */
+    teamName?: string;
+    /** Team description */
+    description?: string;
+    /** Members to include (for create) */
+    members?: TeamMember[];
+}
+export declare const TEAM_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly action: {
+            readonly type: "string";
+            readonly enum: readonly ["create", "delete", "list", "status"];
+            readonly description: "Team action: create (new team), delete (disband), list (all teams), status (team details).";
+        };
+        readonly teamName: {
+            readonly type: "string";
+            readonly description: "Team name. Required for create/delete/status.";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly description: "Team description/objective. Used for create.";
+        };
+        readonly members: {
+            readonly type: "array";
+            readonly description: "Team members with roles and tool restrictions.";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly description: "Agent name/role identifier.";
+                    };
+                    readonly role: {
+                        readonly type: "string";
+                        readonly description: "Role description (e.g. 'frontend developer').";
+                    };
+                    readonly tools: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Allowed tools for this member.";
+                    };
+                };
+                readonly required: readonly ["name", "role"];
+            };
+        };
+    };
+    readonly required: readonly ["action"];
+};
+export interface Team {
+    name: string;
+    description?: string;
+    leadId: string;
+    members: TeamMember[];
+    createdAt: string;
+}
+export interface TeamResult {
+    success: boolean;
+    team?: Team;
+    teams?: Team[];
+    error?: string;
+}
+/**
+ * Host-provided team management backend.
+ * Creates agent teams where members coordinate via send_message.
+ */
+export interface TeamToolDeps {
+    createTeam(params: {
+        teamName: string;
+        description?: string;
+        members?: TeamMember[];
+    }): Promise<TeamResult>;
+    deleteTeam(teamName: string): Promise<TeamResult>;
+    listTeams(): Promise<TeamResult>;
+    getTeamStatus(teamName: string): Promise<TeamResult>;
+}
+export declare function createTeamTool(deps: TeamToolDeps): PortableTool<TeamToolParams>;