aws-runtime-bridge 1.9.175 → 1.9.180

package/package/acode/dist/tool-allocation.d.ts

@@ -1,14 +1,66 @@
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 import type { SubAgentType } from "./sub-agent-types.js";
 
 export declare const DEFAULT_TOOL_CATEGORY = "default";
 
+
+
+
 export declare const SUB_AGENT_MANAGEMENT_TOOL_NAMES: Set<string>;
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export declare const AGENT_IDENTITY_MCP_RESTRICTED_TOOLS: Set<string>;
 
 export declare function isAgentIdentityRestrictedTool(tool: AllocatableToolShape): boolean;
 
+
+
+
+
+
 export declare function mergeAllocatableTools<T extends {
     exposedName: string;
 }>(base: readonly T[], extra: readonly T[]): T[];
@@ -25,12 +77,36 @@ export interface AllocatableToolShape {
 
 export declare function toolAllocationCategory(tool: AllocatableToolShape): string;
 
+
+
+
+
+
+
+
+
+
+
+
 export declare function rebindDefaultAgentId<T extends AllocatableToolShape>(tools: readonly T[], agentId: string): T[];
 
+
+
+
+
+
+
+
+
 export declare function toolAllocationAliases(tool: AllocatableToolShape): string[];
 
 export declare function normalizeAllocationPattern(pattern: string): string;
 
+
+
+
+
+
 export declare function matchesToolAllocation(tool: AllocatableToolShape, patterns: readonly string[]): boolean;
 
 export interface ToolCatalogEntry {
@@ -42,10 +118,32 @@ export interface ToolCatalogEntry {
     tools: string[];
 }
 
+
+
+
+
+
+
+
+
 export declare function buildToolCatalog(tools: readonly AllocatableToolShape[]): ToolCatalogEntry[];
 
+
+
+
 export declare const EXPLORE_READONLY_DENIED_TOOLS: Set<string>;
 
+
+
+
+
+
+
+
+
+
+
+
 export declare const SUB_AGENT_ALLOWED_MCP_TOOLS: Set<string>;
 
 export declare const PRESET_EXPLORE = "explore";
@@ -61,9 +159,24 @@ export declare function expandPreset(preset: SubAgentType, catalog: readonly Too
 
 export interface ResolvedToolAllocation {
     
+
+
+
     patterns: string[];
     
     label: SubAgentType;
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
 export declare function resolveToolAllocation(subagentType: SubAgentType, rawTools: readonly string[], catalog: readonly ToolCatalogEntry[]): ResolvedToolAllocation;

package/package/acode/dist/tool-concurrency/index.d.ts

@@ -1,4 +1,12 @@
 
+
+
+
+
+
+
+
+
 export * from "./types.js";
 export * from "./resource-lock.js";
 export * from "./scheduler.js";

package/package/acode/dist/tool-concurrency/observability.d.ts

@@ -1,6 +1,19 @@
 
+
+
+
+
+
+
+
+
 import type { ToolBatchMetrics, ToolConcurrencyMode, ToolLifecycle, ToolTrace } from "./types.js";
 
+
+
+
+
+
 export declare const CONTENTION_THRESHOLD_MS = 5;
 export declare class ToolTraceRecorder {
     private readonly traces;
@@ -15,6 +28,11 @@ export declare class ToolTraceRecorder {
     private maxConcurrentObserved;
     constructor(batchId: string, now?: number);
     
+
+
+
+
+
     register(input: {
         toolCallId: string;
         toolName: string;
@@ -25,17 +43,31 @@ export declare class ToolTraceRecorder {
     
     private now;
     
+
+
+
+
+
     transition(toolCallId: string, status: ToolLifecycle, now?: number): void;
     
     setError(toolCallId: string, error: string): void;
     getTrace(toolCallId: string): ToolTrace | undefined;
     list(): ToolTrace[];
     
+
+
+
+
     finalize(endedAt?: number): ToolBatchMetrics;
     
     formatSummary(): string;
 }
 
+
+
+
+
+
 export declare class ConcurrencyLimiter {
     private readonly limit;
     private available;

package/package/acode/dist/tool-concurrency/resource-lock.d.ts

@@ -1,14 +1,39 @@
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 import { type ResourceAccess, type ResourceClaim } from "./types.js";
 export declare class ResourceLock {
     private readonly activeHolders;
     private readonly writerQueue;
     private readonly readerQueue;
     
+
+
+
+
+
     acquire(claims: readonly ResourceClaim[], defaultAccess: ResourceAccess): Promise<() => void>;
     
     hasWaiters(): boolean;
     
+
+
+
+
+
     private canAcquireNow;
     
     private conflictsWithActive;
@@ -20,6 +45,11 @@ export declare class ResourceLock {
     private drain;
 }
 
+
+
+
+
+
 export declare function claimsConflict(left: ResourceClaim, right: ResourceClaim): boolean;
 
 export declare function getSharedResourceLock(): ResourceLock;

package/package/acode/dist/tool-concurrency/scheduler.d.ts

@@ -1,4 +1,17 @@
 
+
+
+
+
+
+
+
+
+
+
+
+
+
 import { type ResourceScope, type ToolConcurrencyMode, type ToolConcurrencyPlan, type ResourceClaim } from "./types.js";
 
 export interface ToolScheduleInput {
@@ -26,5 +39,11 @@ export interface ToolScheduleResult {
 }
 export declare class ToolConcurrencyScheduler {
     
+
+
+
+
+
+
     schedule(inputs: readonly ToolScheduleInput[]): ToolScheduleResult;
 }

package/package/acode/dist/tool-concurrency/types.d.ts

@@ -1,9 +1,36 @@
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export type ResourceAccess = "read" | "write" | "exclusive";
 
+
+
+
+
+
+
 export type ToolConcurrencyMode = ResourceAccess | "blocking";
 
+
+
+
+
+
+
 export type ResourceScope = "exact" | "workspace" | "unknown";
 
 export interface ResourceClaim {
@@ -20,6 +47,8 @@ export interface ToolConcurrencyDeclaration {
     resourceScope?: ResourceScope;
 }
 
+
+
 export interface ToolConcurrencyPlan {
     toolCallId: string;
     toolName: string;
@@ -56,8 +85,23 @@ export interface ToolBatchMetrics {
     batchId: string;
     toolCount: number;
     
+
+
+
+
+
     parallelism: number;
     
+
+
+
+
+
+
+
+
+
+
     speedup: number;
     
     wallClockMs: number;
@@ -71,10 +115,23 @@ export interface ToolBatchMetrics {
     traces: ToolTrace[];
 }
 
+
+
+
+
+
 export declare function resourceAncestors(key: string): string[];
 
+
+
+
+
+
 export declare function resourceIsAncestorOrSelf(ancestor: string, descendant: string): boolean;
 
 export declare function resourceKeysOverlap(left: string, right: string): boolean;
 
+
+
+
 export declare function normalizeResourceKey(key: string, platform?: NodeJS.Platform): string;

package/package/acode/dist/tool-group-manager.d.ts

@@ -1,4 +1,27 @@
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 import type { ACodeBuiltInTool, JsonObject } from "./built-in-file-tools.js";
 import type { ACodePluginBridge } from "./plugin-types.js";
 export type CapabilityState = "disabled" | "collapsed" | "expanded";
@@ -12,10 +35,26 @@ export interface ToolGroupRegistration {
     
     collapsible: boolean;
     
+
+
+
     toolNames?: readonly string[];
     
+
+
+
+
+
+
+
+
+
     serverName?: string;
     
+
+
+
+
     pluginName?: string;
 }
 export interface ToolGroupManagerOptions {
@@ -34,6 +73,27 @@ export declare const PLUGIN_GROUP_KEY_PREFIX = "plugin:";
 export declare function pluginGroupKeyOf(pluginName: string): string;
 
 export declare function isPluginGroupKey(key: string): boolean;
+
+
+
+
+
+
+
+
+
+
+
+
+export declare const BUILTIN_NAMED_TOOL_GROUPS: readonly Omit<ToolGroupRegistration, "collapsible" | "summary">[];
+
+
+
+
+
+export declare const BUILTIN_NAMED_TOOL_GROUP_SUMMARIES: Readonly<Record<string, string>>;
+
+export declare function registerBuiltinNamedToolGroups(manager: ToolGroupManager): void;
 export declare class ToolGroupManager {
     private groups;
     private expandedGroups;
@@ -50,22 +110,89 @@ export declare class ToolGroupManager {
     isEnabled(key: string): boolean;
     isExpanded(key: string): boolean;
     
+
+
+
+
+
+
     expand(key: string): number;
     
+
+
     collapse(key: string): number;
     
     resetExpanded(): void;
     
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     shouldShowToLLM(groupKey: string | undefined): boolean;
     
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     getGroupForExposedName(exposedName: string): string | undefined;
     
+
+
     findGroupByServerName(serverName: string): string | undefined;
     
+
+
     shouldShowToLLMByName(exposedName: string): boolean;
     
+
+
+
+
+
+
     claimedToolNamesBySubGroups(): Set<string>;
     
+
+
+
+
+
+
     listToolManifests(key: string, tools: ReadonlyArray<{
         exposedName: string;
         description?: string;
@@ -76,19 +203,53 @@ export declare class ToolGroupManager {
         inputSchema?: unknown;
     }>;
     
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     buildCapabilityPrompt(): string;
     
+
+
+
     registerFromMeta(groupKey: string, label?: string, summary?: string, toolName?: string): void;
     
+
+
     addToolName(groupKey: string, toolName: string): void;
 }
 
+
+
+
+
+
+
+
+
+
+
+
 export interface CapabilityToolRelay {
     
     handlesGroup(group: string): boolean;
     
     handlesTool(toolName: string): boolean;
     
+
+
+
     expand(group: string): Promise<Array<{
         name: string;
         description?: string;
@@ -97,6 +258,9 @@ export interface CapabilityToolRelay {
     
     collapse(group: string): Promise<void>;
     
+
+
+
     call(toolName: string, args: JsonObject): Promise<{
         ok: boolean;
         result?: unknown;
@@ -117,22 +281,53 @@ export interface ExpandToolsDeps {
     pluginBridge?: ACodePluginBridge;
 }
 
+
+
+
+
+
+
+
 export declare function createExpandToolsTool(deps: ExpandToolsDeps): ACodeBuiltInTool;
 export interface CallToolDeps {
     toolGroupManager: ToolGroupManager;
     pluginBridge?: ACodePluginBridge;
     
+
+
+
     findTool: (exposedName: string) => {
         kind: "mcp" | "builtin";
         group?: string;
         toolName: string;
     } | undefined;
     
+
+
+
     dispatchTool: (toolName: string, args: JsonObject, context?: {
         toolCallId?: string;
     }) => Promise<unknown>;
     
+
+
+
     capabilityToolRelay?: CapabilityToolRelay;
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export declare function createCallToolTool(deps: CallToolDeps): ACodeBuiltInTool;