@wenathlan/devthink 2.0.14 → 2.0.19

package/dist/swarm.d.ts

@@ -1,328 +0,0 @@
-/**
- * The swarm module of the 1.1.90 consolidation: every correlated variation of the swarm logic interned in this one file, so the module family carries one surface without duplicate variations.
- * The correlation is the multi agent swarm organized over one shared queue and one shared board: orchestration holds the organizing topology (leader worker election by user rule, work slicing, result collection, worker scaling inside the user bound, the planner executor split with step reporting, critic reviews, verifier checks, the progressboard aggregation, human decided escalations, arbitration of competing claims and consensus rounds with quorum); taskqueue holds the shared work every agent of the swarm claims from (lanes, priorities, claims with heartbeats, work stealing with lane ownership, completion policy and the requeue of orphaned tasks); and blackboard is the shared memory every agent reads with no relay (sections, posting with authors, freshness filtered reads, retirement by the user window and the consent class inheritance of the source extraction).
- * Orchestration never bypasses review: the leader only organizes work whose proposals still pass the same human review, the critic reads outputs without acting on the page, and every escalation lands on the user.
- */
-import type { agentidentity, arbitrationrule, boardmilestone, consensusround, consensusvote, criticreview, escalationrecord, leaderworker, plannerexecutor, progressboard, reviewrequest, reviewverdict, taskitem, taskqueue, verifiercheck } from "./types.js";
-/**
- * Multi agent orchestration logic of the 1.1.59 family.
- * Every correlated rule for the leader worker topology (election by user rule, work slicing, result collection, worker scaling), the planner executor split with step reporting, critic reviews over agent outputs, verifier checks of result claims, the progressboard aggregation, escalations that stay human decided, arbitration of competing claims and consensus rounds with quorum lives in this file.
- * Orchestration never bypasses review: the leader only organizes work whose proposals still pass the same human review, the critic reads outputs without acting on the page and every escalation lands on the user.
- */
-/** Elects the leader of the swarm and builds the leader worker topology: the user rule names the leader (first registration or one named agent), the live workers, critics and verifiers join their lanes by role, and the topology records the election. */
-export declare function electleader(input: {
-    agents: agentidentity[];
-    id: string;
-    rule?: {
-        kind: "first" | "named";
-        agentid?: string;
-    };
-    now: number;
-}): leaderworker;
-/** Slices the tasks across the workers of the topology: the workers take turns over the queued and claimed tasks in queue order, every slice names the task payload it owns and the assignments record the worker, the task and the slice. */
-export declare function assignwork(input: {
-    topology: leaderworker;
-    tasks: taskitem[];
-    now: number;
-}): leaderworker;
-/** Gathers the worker outputs with status: every assignment reports its state while the outputs the workers returned land beside their tasks, and the missing list names the assignments still without an output. */
-export declare function collectresults(input: {
-    topology: leaderworker;
-    outputs: Array<{
-        workerid: string;
-        taskid: string;
-        state: string;
-        summary: string;
-    }>;
-}): {
-    gathered: Array<{
-        workerid: string;
-        taskid: string;
-        state: string;
-        summary: string;
-    }>;
-    missing: string[];
-};
-/** Scales the worker lane by load: queued work beyond the current workers adds the live worker role agents the swarm already holds (never past the user configured bound while one exists), idle workers retire down to the work left, and no engine cap ever exists. */
-export declare function scaleworkers(input: {
-    topology: leaderworker;
-    agents: agentidentity[];
-    pending: number;
-    bound?: number;
-    now: number;
-}): {
-    topology: leaderworker;
-    added: string[];
-    retired: string[];
-    reason: string;
-};
-/** Splits one task between the planner and the executor: the plan owner agent drafts the reviewed plan while the run owner agent executes it, and the split record starts empty of step reports. */
-export declare function plannersplit(input: {
-    id: string;
-    planownerid: string;
-    runownerid: string;
-    taskid?: string;
-    now: number;
-}): plannerexecutor;
-/** Reports one executor step outcome back to the planner agent: the executor appends its report to the split record so the planner reads every step result. */
-export declare function reportstep(input: {
-    split: plannerexecutor;
-    stepid: string;
-    outcome: "done" | "failed";
-    detail: string;
-    now: number;
-}): plannerexecutor;
-/** Routes one review request to a reviewing agent: the request names the subject and payload and stays open until its ack, its answer or its user configured timeout. */
-export declare function requestreview(input: {
-    requests: reviewrequest[];
-    id: string;
-    fromagentid: string;
-    toagentid: string;
-    subject: string;
-    payload: string;
-    timeoutms?: number;
-    now: number;
-}): reviewrequest[];
-/** Acks one review request: the reviewing agent confirms receipt while the answer still waits. */
-export declare function ackreview(input: {
-    requests: reviewrequest[];
-    id: string;
-    now: number;
-}): reviewrequest[];
-/** Applies the critic verdict to one review request: the review carries the verdict, the issues and the required changes while the request closes as answered. */
-export declare function applyreview(input: {
-    requests: reviewrequest[];
-    id: string;
-    reviewerid: string;
-    verdict: reviewverdict;
-    issues: string[];
-    requiredchanges: string[];
-    taskid?: string;
-    now: number;
-}): {
-    review: criticreview;
-    requests: reviewrequest[];
-};
-/** Sweeps the review requests past their user configured timeout: an unanswered request without an ack or an answer times out and the requester reads the expiry. */
-export declare function sweepreviews(input: {
-    requests: reviewrequest[];
-    now: number;
-}): {
-    requests: reviewrequest[];
-    timedout: string[];
-};
-/** Records one verifier check of a result claim: the verifier names the claim, the method it used and the pass or fail outcome with its evidence; the check itself never writes to the page. */
-export declare function checkclaim(input: {
-    id: string;
-    verifierid: string;
-    claimagentid: string;
-    claim: string;
-    method: string;
-    outcome: "pass" | "fail";
-    evidence?: string;
-    taskid?: string;
-    now: number;
-}): verifiercheck;
-/** Builds the progressboard that aggregates the swarm: one lane per live agent with its role, state, lane of work, current task and milestones, so the user reads every agent at once. */
-export declare function boardstate(input: {
-    agents: agentidentity[];
-    queue: taskqueue;
-    topology?: leaderworker;
-    milestones?: Record<string, boardmilestone[]>;
-    now: number;
-}): progressboard;
-/** Lifts one stalled agent decision to the user with its full context: the escalation stays open until the user writes the decision because escalations are always human decided. */
-export declare function escalate(input: {
-    id: string;
-    agentid: string;
-    subject: string;
-    context: string;
-    now: number;
-}): escalationrecord;
-/** Resolves one escalation with the decision the user wrote; the decision time records and the record closes. */
-export declare function resolveescalation(input: {
-    escalation: escalationrecord;
-    decision: string;
-    now: number;
-}): escalationrecord;
-/** Orders competing resource claims by the user configured arbitration rule: the priority strategy follows the user ordered agent list, the age strategy gives the resource to the oldest claim and the leader strategy names the elected leader first. */
-export declare function arbitrate(input: {
-    rule: arbitrationrule;
-    leaderid?: string;
-    claims: Array<{
-        agentid: string;
-        claimedat: number;
-    }>;
-}): string[];
-/** Opens one consensus round: the subject stays plain language and the quorum stays the user configured value the round needs to carry. */
-export declare function openconsensus(input: {
-    id: string;
-    subject: string;
-    quorum: number;
-    now: number;
-}): consensusround;
-/** Collects one verdict into a consensus round: an agent votes once, the round stays open until the votes carry or the round closes, and the quorum counts yes votes only. */
-export declare function castvote(input: {
-    round: consensusround;
-    agentid: string;
-    vote: consensusvote;
-    now: number;
-}): consensusround;
-/** Reads the state of one consensus round: the yes, no and abstain counts beside the quorum so the panel shows the votes and the quorum state at once. */
-export declare function consensusstate(round: consensusround): {
-    yes: number;
-    no: number;
-    abstain: number;
-    quorum: number;
-    state: string;
-};
-/**
- * Shared task queue logic of the 1.1.58 multi agent family.
- * Every correlated rule for lanes, priorities, claims, work stealing with lane ownership, completion, heartbeats and the requeue of orphaned tasks lives in this file.
- * The queue never executes anything: a claimed task only names the work whose proposal still passes the same human review every single agent proposal passes.
- */
-/** One lane ownership rule the user configures: the lane name and the roles allowed to steal from it; a lane without a rule stays open to every agent of the approved swarm. */
-export interface laneownership {
-    lane: string;
-    roles: string[];
-}
-/** Builds one empty queue with the user configured lanes, priority scale and completion policy; the empty set of lanes accepts any lane name the user enqueues. */
-export declare function emptyqueue(input?: {
-    lanes?: string[];
-    priorities?: number[];
-    completionpolicy?: "all" | "any";
-}): taskqueue;
-/** Enqueues one task item into a lane with its priority; a configured lane list refuses unknown lanes and the payload stays the plain language text the user typed. */
-export declare function enqueue(input: {
-    queue: taskqueue;
-    id: string;
-    lane: string;
-    priority: number;
-    payload: string;
-    now: number;
-}): taskqueue;
-/** Lets one agent claim the highest priority queued task; the claim carries the heartbeat time that keeps it alive and an agent holds one task at a time. */
-export declare function claim(input: {
-    queue: taskqueue;
-    agentid: string;
-    now: number;
-}): {
-    queue: taskqueue;
-    task?: taskitem;
-};
-/** Lets one idle agent steal a queued task from a named lane; the lane ownership rules the user configures refuse agents whose role holds no grant for the lane. */
-export declare function steal(input: {
-    queue: taskqueue;
-    agentid: string;
-    role: string;
-    fromlane: string;
-    ownership?: laneownership[];
-    now: number;
-}): {
-    queue: taskqueue;
-    task?: taskitem;
-};
-/** Marks one task done and releases the claim of the agent that held it. */
-export declare function complete(input: {
-    queue: taskqueue;
-    taskid: string;
-    now: number;
-}): taskqueue;
-/** Cancels one queued or claimed task; the cancelled task releases its claim and leaves the queue. */
-export declare function canceltask(input: {
-    queue: taskqueue;
-    taskid: string;
-    now: number;
-}): taskqueue;
-/** Refreshes the heartbeats of every live claim of one agent so a working agent keeps its tasks. */
-export declare function claimheartbeat(input: {
-    queue: taskqueue;
-    agentid: string;
-    now: number;
-}): taskqueue;
-/** Returns the orphaned tasks to their lane: a claim whose heartbeat stayed silent past the user configured expiry window releases and the task waits as queued again; an absent window never expires a claim. */
-export declare function requeue(input: {
-    queue: taskqueue;
-    now: number;
-    window?: number;
-}): {
-    queue: taskqueue;
-    requeued: string[];
-};
-/** Reports every lane with its queued, claimed, done and cancelled task counts and the live claims, so the queue view reads the lanes at a glance. */
-export declare function lanereport(queue: taskqueue): Array<{
-    lane: string;
-    queued: number;
-    claimed: number;
-    done: number;
-    cancelled: number;
-    claims: Array<{
-        agentid: string;
-        taskid: string;
-        heartbeatat: number;
-    }>;
-}>;
-/** Evaluates the completion policy of the queue: all completes only when every task is done while any completes with the first done task. */
-export declare function queuecomplete(queue: taskqueue): boolean;
-/** Counts the tasks by claim state for the popup gauge: the claimed tasks are the active work of the swarm. */
-export declare function taskcounts(queue: taskqueue): {
-    queued: number;
-    claimed: number;
-    done: number;
-    cancelled: number;
-};
-import type { actionrisk, blackboard, blackboardentry, blackboardsection } from "./types.js";
-/**
- * Blackboard shared memory logic of the 1.1.58 multi agent family.
- * Every correlated rule for the shared sections, posting with authors, reading with freshness filters, retirement by the user configured window and the consent class inheritance of the source extraction lives in this file.
- * Every agent of the swarm reads the same board: the writes of one agent are visible to every other agent with no relay.
- */
-/** The blackboard sections the swarm shares by default; the user may narrow the list to the sections in use. */
-export declare const blackboardsections: blackboardsection[];
-/** Builds one empty blackboard over the four shared sections with no retirement window; an absent window keeps every entry. */
-export declare function emptyboard(sections?: blackboardsection[]): blackboard;
-/** Writes one entry to a section with its author: the key and value stay the plain text the author typed, the section joins the board when it is new and the entry carries the consent class of its source extraction. */
-export declare function postentry(input: {
-    board: blackboard;
-    id: string;
-    key: string;
-    value: string;
-    section: blackboardsection;
-    author: string;
-    valuekind?: "text" | "json";
-    consentclass?: actionrisk;
-    now: number;
-}): blackboard;
-/** True when one entry stayed fresh inside the window; an absent window keeps every entry fresh. */
-export declare function entryfresh(entry: blackboardentry, now: number, window?: number): boolean;
-/** Returns the entries of one section with freshness filters: retired entries stay out and an optional window keeps only the fresh ones; an absent section returns every live entry. */
-export declare function readentries(input: {
-    board: blackboard;
-    section?: blackboardsection;
-    freshness?: number;
-    now: number;
-}): blackboardentry[];
-/** Retires the stale entries by the user configured policy: entries older than the retirement window of the board receive their retirement time while an absent window retires nothing. */
-export declare function retireentries(input: {
-    board: blackboard;
-    now: number;
-}): {
-    board: blackboard;
-    retired: string[];
-};
-/** Retires one entry by its id; the retired entry stays stored for the audit trail while the live reads stop showing it. */
-export declare function retireentry(input: {
-    board: blackboard;
-    entryid: string;
-    now: number;
-}): blackboard;
-/** Inherits the consent class of the source extraction into one entry: the reader of the entry sees the class of the extraction it came from, so a sensitive extraction stays sensitive on the board. */
-export declare function inheritconsent(entry: blackboardentry, sourcerisk: actionrisk): blackboardentry;
-/** Summarizes the board for the panel: every section with its live entry count, its authors and the freshest posting time. */
-export declare function boardsummary(board: blackboard, now: number): Array<{
-    section: blackboardsection;
-    entries: number;
-    authors: string[];
-    freshestat?: number;
-}>;
-//# sourceMappingURL=swarm.d.ts.map

package/dist/tools.d.ts

@@ -1,170 +0,0 @@
-/**
- * The tools module of the 1.1.90 consolidation: every correlated variation of the tool catalog and call runtime logic interned in this one file, so the module family carries one surface without duplicate variations.
- * The correlation is the tools family: toolcatalog holds the catalog of the 1.1.54 agent protocol (the tool namespaces, the json schema layout of every tool def, the read and gated tools of the browser, workflow, memory and system domains, the catalog build, the name resolution and the per namespace listing); toolcalls holds the call runtime of the 1.1.56 agent protocol part three (the per client rate limits, the structured error mapping with its retry hints — exported here as callretryhintof so the session family keeps the canonical retryhintof — the idempotency replay window, the ordered batch calls, the tool dry runs, the tool mocks and the call contexts).
- * No budget, window or mock is ever invented: every rate limit and idempotency window stays the user's choice, and no tool call ever bypasses the dispatch gates.
- */
-import type { actionkind, actionrisk, toolcatalog, tooldef, toolnamespace, toolschema, toolschemaproperty, agentsession, agentplan, batchoutcome, callcontext, callratelimit, clientrecord, idempotencykey, idempotencyrecord, retryhint, structurederror, tooldryrun, toolmock, toolresult } from "./types.js";
-/**
- * Tool catalog of the 1.1.54 and 1.1.55 agent protocol family, widened by the 1.1.84 mcp server mode.
- * Every mcp tool definition, version and json schema lives in this file: the four tool domains (browser, workflow, memory and system) with their namespace prefixes, the version appended to every tooldef for compatibility checks, the json schema generation that maps every tool input to typed properties with required markers and default values, the plain language descriptions that state the consent class and side effects of every tool and end with the openapi style field layout of their inputs, the consent metadata of the tools with side effects — the review requirement, the policy derived risk class, the approval gate requirement and the session origin scope — and the name resolution that keeps colliding base names apart through their namespace prefix. The 1.1.84 family adds the plan proposal tool with the full step grammar, the review gate tool that waits for the human answer, the observation read tool and the session record tool.
- * The catalog stays pure data: policy validates it against the action kind grammar and the server lists it through the tools/list handshake, while no tool bypasses review — read only tools run under the dryrun risk class and every tool with side effects names the approved plan step it executes.
- */
-/** The catalog version of the 1.1.84 family; every tooldef appends its own version for compatibility checks, and the bump to 2 adds the plan proposal, review gate, observation and session tools with the openapi style field layout of every description. */
-export declare const toolcatalogversion = 2;
-/** The tool namespaces the catalog serves, in the documented order of the panel view. */
-export declare const toolnamespaces: toolnamespace[];
-/** The reviewed action kinds of every namespace so policy can validate that tools stay in their domain. */
-export declare const domainkinds: Record<toolnamespace, actionkind[]>;
-/** Builds the json schema of one tool input from its typed property map: required properties are listed and the options object carries the reviewed empty default. */
-export declare function toolschemaof(properties: Record<string, toolschemaproperty>): toolschema;
-/** Renders the openapi style field layout of one tool input schema: every property lists its name, its json schema type and its required star while a reviewed default renders after an equals sign, so every tool description ends with the same field layout an openapi document carries and a client reads the wire shape from the description alone. */
-export declare function openapilayout(schema: toolschema): string;
-/** Builds the full mcp tool catalog of the four domains with the catalog version stamped on every record and the openapi style field layout of its inputs appended to every description. */
-export declare function buildtoolcatalog(): toolcatalog;
-/** Returns every tool of the catalog flattened across the domains. */
-export declare function alltools(catalog: toolcatalog): tooldef[];
-/** Prefixes one base tool name with its namespace so tool names never collide across domains. */
-export declare function toolname(namespace: toolnamespace, base: string): string;
-/** Resolves one tool by its namespaced name; a bare name resolves only when exactly one tool of the catalog carries it, so colliding base names stay unambiguous through their prefix. */
-export declare function resolvetool(catalog: toolcatalog, name: string): tooldef | undefined;
-/** Returns the namespace of one tool name; names without a dot carry no namespace. */
-export declare function namespaceof(name: string): toolnamespace | undefined;
-/** Groups the tools of the catalog by namespace for the panel view and the tools/list report. */
-export declare function toolsbynamespace(catalog: toolcatalog): Array<{
-    namespace: toolnamespace;
-    version: number;
-    tools: tooldef[];
-}>;
-/**
- * Tool call runtime of the 1.1.56 agent protocol part three.
- * Every call runtime concern lives in this file: the per client rate limits that count calls inside their window and answer excess with a structured error carrying its retry after, the structured error mapping that turns executor failures into codes with retry hints, the retry hint classification of retryable timeouts, busy windows and consent refusals, the idempotency keys that replay stored results inside their window and expire after it, the ordered batch calls that stop on the first error when the flag requests it, the tool dry runs that evaluate arguments and consent without side effects, the tool mocks that answer declared tools with canned results only in test contexts, and the call contexts that isolate the concurrent calls of concurrent clients while every call lands its audit entry with its idempotency key and outcome.
- * The runtime stays consent-first: a dry run never mutates the page, a mock never touches the browser and a rate limit never invents a budget the user did not configure.
- */
-/** The default idempotency replay window of five minutes; any user configured window wins and an absent window keeps the replay forever. */
-export declare const defaultidempotencywindowms = 300000;
-/** Counts one client tool call against its per client rate limit: a window past its end resets the counter, a configured budget refuses the call that would exceed it with its retry after window and an absent limit or budget keeps the client unbounded because no silent default ever applies. */
-export declare function applyratelimit(input: {
-    limits: callratelimit[];
-    clientid: string;
-    now: number;
-}): {
-    allowed: boolean;
-    used: number;
-    budget?: number;
-    retryafter?: number;
-    limit?: callratelimit;
-    limits: callratelimit[];
-};
-/** Builds one structured error with its code, message, retry hint and optional retry after window. */
-export declare function structurederrorof(input: {
-    code: string;
-    message: string;
-    retryhint: retryhint;
-    retryafter?: number;
-}): structurederror;
-/** Classifies one failure into its retry hint: timeouts stay retryable, busy windows and rate limits wait for their retry after while consent refusals never retry. */
-export declare function callretryhintof(failure: {
-    code?: string;
-    message?: string;
-}): retryhint;
-/** Maps one executor failure onto its structured error: the code and message ride the answer while the retry hint classifies the retryable timeouts, busy windows and consent refusals. */
-export declare function maptoolerror(input: {
-    failure: {
-        code?: string;
-        message: string;
-    } | Error;
-    retryafter?: number;
-}): structurederror;
-/** Checks one idempotency key: a live record of the same client replays its stored result while an expired, foreign or unknown key reports why nothing replayed. */
-export declare function checkidempotency(input: {
-    records: idempotencyrecord[];
-    key: idempotencykey;
-    clientid: string;
-    now: number;
-}): {
-    replay?: toolresult;
-    record?: idempotencyrecord;
-    reason?: string;
-};
-/** Stores one idempotency record for replay: the key, the calling client, the tool and the result with its user configured window; a repeated key of the same client overwrites its record. */
-export declare function recordidempotency(input: {
-    records: idempotencyrecord[];
-    key: idempotencykey;
-    clientid: string;
-    tool: string;
-    result: toolresult;
-    now: number;
-    window?: number;
-}): idempotencyrecord[];
-/** Expires the idempotency records past their window: expired records leave the live set while their keys never replay. */
-export declare function expireidempotency(records: idempotencyrecord[], now: number): idempotencyrecord[];
-/** Executes one ordered batch call: every member runs in order through the injected executor, each member lands its own outcome and the batch stops at the first error when the stop on error flag requests it. */
-export declare function runbatch(input: {
-    calls: Array<{
-        id: string;
-        name: string;
-        params: Record<string, unknown>;
-    }>;
-    stoponerror: boolean;
-    now: number;
-    execute: (call: {
-        id: string;
-        name: string;
-        params: Record<string, unknown>;
-    }, index: number) => Promise<{
-        ok: boolean;
-        result?: toolresult;
-        error?: structurederror;
-    }>;
-}): Promise<{
-    outcomes: batchoutcome[];
-    stoppedat?: string;
-}>;
-/** Runs one tool dry run: the arguments validate against the tool json schema, the same consent gates that guard execution evaluate the call and the record stays free of page mutations by construction because nothing ever executes. */
-export declare function dryruntool(input: {
-    tool: tooldef;
-    params: Record<string, unknown>;
-    client: clientrecord;
-    session?: agentsession;
-    plan?: agentplan;
-    origin: string;
-    stepid?: string;
-    now: number;
-    callid?: string;
-}): tooldryrun;
-/** Applies one tool mock: a matching mock of a test context answers with its canned result without touching the browser while a mock outside a test context is refused and no mock leaves the call to the real gates. */
-export declare function applymock(input: {
-    mocks: toolmock[];
-    tool: string;
-}): {
-    result?: toolresult;
-    reason?: string;
-};
-/** Opens one isolated call context for a concurrent client call: the call id, the client, the tool and the markers of the 1.1.56 family ride the record while the chunk counter starts at zero. */
-export declare function begincall(input: {
-    clientid: string;
-    tool: string;
-    callid?: string;
-    idempotencykey?: idempotencykey;
-    dryrun?: boolean;
-    batchid?: string;
-    now: number;
-}): callcontext;
-/** Closes one call context with its outcome: the context turns done or failed with its end time while the chunks counter and the partial result of a cancellation survive for the answer. */
-export declare function endcall(input: {
-    contexts: callcontext[];
-    callid: string;
-    ok: boolean;
-    errorcode?: string;
-    partial?: toolresult;
-    now: number;
-}): {
-    contexts: callcontext[];
-    context?: callcontext;
-    reason?: string;
-};
-/** Grades one batch call by its most sensitive member: the batch takes the sensitive grade when any member is sensitive and runs only behind the approval gates. */
-export declare function batchrisk(calls: Array<{
-    risk: actionrisk;
-}>): actionrisk;
-//# sourceMappingURL=tools.d.ts.map