opencode-swarm 6.14.0 → 6.14.12

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/config/schema.d.ts

@@ -99,6 +99,7 @@ export declare const ContextBudgetConfigSchema: z.ZodObject<{
     critical_threshold: z.ZodDefault<z.ZodNumber>;
     model_limits: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     max_injection_tokens: z.ZodDefault<z.ZodNumber>;
+    tracked_agents: z.ZodDefault<z.ZodArray<z.ZodString>>;
     scoring: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         max_candidates: z.ZodDefault<z.ZodNumber>;
@@ -126,6 +127,12 @@ export declare const ContextBudgetConfigSchema: z.ZodObject<{
             json: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    enforce: z.ZodDefault<z.ZodBoolean>;
+    prune_target: z.ZodDefault<z.ZodNumber>;
+    preserve_last_n_turns: z.ZodDefault<z.ZodNumber>;
+    recent_window: z.ZodDefault<z.ZodNumber>;
+    enforce_on_agent_switch: z.ZodDefault<z.ZodBoolean>;
+    tool_output_mask_threshold: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type ContextBudgetConfig = z.infer<typeof ContextBudgetConfigSchema>;
 export declare const EvidenceConfigSchema: z.ZodObject<{
@@ -451,6 +458,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
         critical_threshold: z.ZodDefault<z.ZodNumber>;
         model_limits: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         max_injection_tokens: z.ZodDefault<z.ZodNumber>;
+        tracked_agents: z.ZodDefault<z.ZodArray<z.ZodString>>;
         scoring: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
             max_candidates: z.ZodDefault<z.ZodNumber>;
@@ -478,6 +486,12 @@ export declare const PluginConfigSchema: z.ZodObject<{
                 json: z.ZodDefault<z.ZodNumber>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
+        enforce: z.ZodDefault<z.ZodBoolean>;
+        prune_target: z.ZodDefault<z.ZodNumber>;
+        preserve_last_n_turns: z.ZodDefault<z.ZodNumber>;
+        recent_window: z.ZodDefault<z.ZodNumber>;
+        enforce_on_agent_switch: z.ZodDefault<z.ZodBoolean>;
+        tool_output_mask_threshold: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
     guardrails: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;

package/dist/hooks/context-budget.d.ts

@@ -10,6 +10,9 @@ interface MessageInfo {
     role: string;
     agent?: string;
     sessionID?: string;
+    modelID?: string;
+    providerID?: string;
+    [key: string]: unknown;
 }
 interface MessagePart {
     type: string;

package/dist/hooks/index.d.ts

@@ -5,7 +5,9 @@ export { createDelegationGateHook } from './delegation-gate';
 export { createDelegationTrackerHook } from './delegation-tracker';
 export { extractCurrentPhase, extractCurrentPhaseFromPlan, extractCurrentTask, extractCurrentTaskFromPlan, extractDecisions, extractIncompleteTasks, extractIncompleteTasksFromPlan, extractPatterns, } from './extractors';
 export { createGuardrailsHooks } from './guardrails';
+export { classifyMessage, classifyMessages, containsPlanContent, isDuplicateToolRead, isStaleError, isToolResult, MessagePriority, type MessagePriorityType, type MessageWithParts, } from './message-priority';
 export { consolidateSystemMessages } from './messages-transform';
+export { extractModelInfo, NATIVE_MODEL_LIMITS, PROVIDER_CAPS, resolveModelLimit, } from './model-limits';
 export { createPhaseMonitorHook } from './phase-monitor';
 export { createPipelineTrackerHook } from './pipeline-tracker';
 export { createSystemEnhancerHook } from './system-enhancer';

package/dist/hooks/message-priority.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Message Priority Classifier Hook
+ *
+ * Provides zero-cost message priority classification to enable intelligent
+ * context pruning. Messages are tagged with priority tiers (0-4) so that
+ * low-priority messages are removed first during context budget pressure.
+ *
+ * Priority tiers:
+ * - CRITICAL (0): System prompt, plan state, active instructions
+ * - HIGH (1): User messages, current task context, tool definitions
+ * - MEDIUM (2): Recent assistant responses, recent tool results
+ * - LOW (3): Old assistant responses, old tool results, confirmations
+ * - DISPOSABLE (4): Duplicate reads, superseded writes, stale errors
+ */
+/**
+ * Message priority tiers for context pruning decisions.
+ * Lower values = higher priority (kept longer during pruning).
+ */
+export declare const MessagePriority: {
+    /** System prompt, plan state, active instructions - never prune */
+    readonly CRITICAL: 0;
+    /** User messages, current task context, tool definitions */
+    readonly HIGH: 1;
+    /** Recent assistant responses, recent tool results (within recentWindowSize) */
+    readonly MEDIUM: 2;
+    /** Old assistant responses, old tool results */
+    readonly LOW: 3;
+    /** Duplicate reads, superseded writes, stale errors - prune first */
+    readonly DISPOSABLE: 4;
+};
+export type MessagePriorityType = (typeof MessagePriority)[keyof typeof MessagePriority];
+/** Message structure matching the format from context-budget.ts */
+interface MessageInfo {
+    role?: string;
+    agent?: string;
+    sessionID?: string;
+    modelID?: string;
+    providerID?: string;
+    toolName?: string;
+    toolArgs?: unknown;
+    [key: string]: unknown;
+}
+interface MessagePart {
+    type?: string;
+    text?: string;
+    [key: string]: unknown;
+}
+export interface MessageWithParts {
+    info?: MessageInfo;
+    parts?: MessagePart[];
+}
+/**
+ * Checks if text contains .swarm/plan or .swarm/context references
+ * indicating swarm state that should be preserved.
+ *
+ * @param text - The text content to check
+ * @returns true if the text contains plan/context references
+ */
+export declare function containsPlanContent(text: string): boolean;
+/**
+ * Checks if a message is a tool result (assistant message with tool call).
+ *
+ * @param message - The message to check
+ * @returns true if the message appears to be a tool result
+ */
+export declare function isToolResult(message: MessageWithParts): boolean;
+/**
+ * Checks if two consecutive tool read calls are duplicates
+ * (same tool with same first argument).
+ *
+ * @param current - The current message
+ * @param previous - The previous message
+ * @returns true if this is a duplicate tool read
+ */
+export declare function isDuplicateToolRead(current: MessageWithParts, previous: MessageWithParts): boolean;
+/**
+ * Checks if a message contains an error pattern and is stale
+ * (more than the specified number of turns old).
+ *
+ * @param text - The message text to check
+ * @param turnsAgo - How many turns ago the message was sent
+ * @returns true if the message is a stale error
+ */
+export declare function isStaleError(text: string, turnsAgo: number): boolean;
+/**
+ * Classifies a message by priority tier for intelligent pruning.
+ *
+ * @param message - The message to classify
+ * @param index - Position in messages array (0-indexed)
+ * @param totalMessages - Total number of messages
+ * @param recentWindowSize - Number of recent messages to consider MEDIUM (default 10)
+ * @returns Priority tier (0=CRITICAL, 1=HIGH, 2=MEDIUM, 3=LOW, 4=DISPOSABLE)
+ */
+export declare function classifyMessage(message: MessageWithParts, index: number, totalMessages: number, recentWindowSize?: number): MessagePriorityType;
+/**
+ * Classifies a batch of messages with duplicate detection.
+ * This function should be called in order (oldest to newest) to properly
+ * detect consecutive duplicate tool reads.
+ *
+ * @param messages - Array of messages to classify
+ * @param recentWindowSize - Number of recent messages to consider MEDIUM (default 10)
+ * @returns Array of priority classifications matching message order
+ */
+export declare function classifyMessages(messages: MessageWithParts[], recentWindowSize?: number): MessagePriorityType[];
+export {};

package/dist/hooks/model-limits.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Provider-Aware Model Limit Resolution
+ *
+ * Resolves context window limits based on the model and provider platform.
+ * The same model has different context limits depending on the provider:
+ * - Claude Sonnet 4.6: 200k native, 128k on Copilot
+ * - GPT-5: 400k native, 128k on Copilot
+ * - Copilot caps ALL models at 128k prompt, regardless of native limit
+ */
+/**
+ * Native model context limits (in tokens) when used on their native platform.
+ */
+export declare const NATIVE_MODEL_LIMITS: Record<string, number>;
+/**
+ * Provider-specific context caps that override native limits.
+ * These are typically lower than native limits (e.g., Copilot caps at 128k).
+ */
+export declare const PROVIDER_CAPS: Record<string, number>;
+/**
+ * Message structure from experimental.chat.messages.transform hook.
+ */
+interface MessageInfo {
+    role: string;
+    agent?: string;
+    sessionID?: string;
+    modelID?: string;
+    providerID?: string;
+    [key: string]: unknown;
+}
+interface MessagePart {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+interface MessageWithParts {
+    info: MessageInfo;
+    parts: MessagePart[];
+}
+/**
+ * Extracts modelID and providerID from the most recent assistant message.
+ *
+ * @param messages - Array of messages from experimental.chat.messages.transform hook
+ * @returns Object containing modelID and/or providerID if found
+ *
+ * @example
+ * const info = extractModelInfo(messages);
+ * // Returns: { modelID: 'claude-sonnet-4-6', providerID: 'anthropic' }
+ * // Or: {} if no assistant messages or fields not found
+ */
+export declare function extractModelInfo(messages: MessageWithParts[]): {
+    modelID?: string;
+    providerID?: string;
+};
+/**
+ * Resolves the context limit for a given model/provider combination.
+ *
+ * Resolution order (first match wins):
+ * 1. Check configOverrides["provider/model"] (e.g., "copilot/claude-sonnet-4-6": 200000)
+ * 2. Check configOverrides[modelID] (e.g., "claude-sonnet-4-6": 200000)
+ * 3. Check PROVIDER_CAPS[providerID] (e.g., copilot → 128000)
+ * 4. Check NATIVE_MODEL_LIMITS with prefix matching (e.g., "claude-sonnet-4" matches "claude-sonnet-4-6-20260301")
+ * 5. Check configOverrides.default
+ * 6. Fall back to 128000
+ *
+ * @param modelID - The model identifier (e.g., "claude-sonnet-4-6", "gpt-5")
+ * @param providerID - The provider identifier (e.g., "copilot", "anthropic")
+ * @param configOverrides - User configuration overrides
+ * @returns The resolved context limit in tokens
+ *
+ * @example
+ * // Provider cap (copilot)
+ * resolveModelLimit("claude-sonnet-4-6", "copilot", {})
+ * // Returns: 128000
+ *
+ * @example
+ * // Native limit (anthropic)
+ * resolveModelLimit("claude-sonnet-4-6", "anthropic", {})
+ * // Returns: 200000
+ *
+ * @example
+ * // Override beats cap
+ * resolveModelLimit("gpt-5", "copilot", { "copilot/gpt-5": 200000 })
+ * // Returns: 200000
+ *
+ * @example
+ * // Prefix match for model variants
+ * resolveModelLimit("claude-sonnet-4-6-20260301", "anthropic", {})
+ * // Returns: 200000
+ *
+ * @example
+ * // Full fallback
+ * resolveModelLimit(undefined, undefined, {})
+ * // Returns: 128000
+ */
+export declare function resolveModelLimit(modelID?: string, providerID?: string, configOverrides?: Record<string, number>): number;
+export {};