maka-agent 0.2.0-dev.30.20260912 → 0.2.0-dev.31.20260913

package/node_modules/@maka/runtime/dist/active-tool-result-working-set.js

@@ -1,218 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-const MAX_NEWER_READ_CANDIDATES_PER_PATH = 64;
-/**
- * Select provider-visible results that a strictly newer completed step makes
- * redundant. The planner is intentionally deterministic and conservative:
- * parallel calls in one step never supersede each other, error results never
- * replace successful evidence, and unknown tools only participate in exact
- * input-and-output deduplication.
- */
-export function planActiveToolResultSupersession(observations) {
-    const decisions = new Map();
-    const newestExact = new Map();
-    const newerReads = new Map();
-    const newestSnapshots = new Map();
-    for (let index = observations.length - 1; index >= 0; index -= 1) {
-        const observation = observations[index];
-        const exactKey = exactObservationKey(observation);
-        const exactReplacement = newestExact.get(exactKey);
-        if (observation.eligible &&
-            exactReplacement &&
-            exactReplacement.stepNumber > observation.stepNumber) {
-            decisions.set(observation.toolCallId, {
-                reason: 'exact_duplicate',
-                supersededByToolCallId: exactReplacement.toolCallId,
-            });
-        }
-        const descriptor = describeObservation(observation.toolName, observation.input);
-        if (observation.eligible && !decisions.has(observation.toolCallId) && descriptor) {
-            const replacement = findSemanticReplacement(observation, descriptor, newerReads, newestSnapshots);
-            if (replacement)
-                decisions.set(observation.toolCallId, replacement);
-        }
-        if (!newestExact.has(exactKey))
-            newestExact.set(exactKey, observation);
-        if (observation.isError || !descriptor)
-            continue;
-        if (descriptor.kind === 'read') {
-            const reads = newerReads.get(descriptor.path) ?? [];
-            if (reads.length < MAX_NEWER_READ_CANDIDATES_PER_PATH)
-                reads.push(observation);
-            newerReads.set(descriptor.path, reads);
-        }
-        else if (!newestSnapshots.has(descriptor.key)) {
-            newestSnapshots.set(descriptor.key, observation);
-        }
-    }
-    return decisions;
-}
-function findSemanticReplacement(observation, descriptor, newerReads, newestSnapshots) {
-    let replacement;
-    if (descriptor.kind === 'read') {
-        replacement = newerReads.get(descriptor.path)?.find((candidate) => {
-            if (candidate.stepNumber <= observation.stepNumber)
-                return false;
-            const candidateDescriptor = describeRead(candidate.input);
-            return Boolean(candidateDescriptor && readCovers(candidateDescriptor, descriptor));
-        });
-    }
-    else {
-        const candidate = newestSnapshots.get(descriptor.key);
-        if (candidate && candidate.stepNumber > observation.stepNumber)
-            replacement = candidate;
-    }
-    if (!replacement)
-        return undefined;
-    return {
-        reason: observation.isError
-            ? 'failure_resolved'
-            : descriptor.kind === 'read'
-                ? 'newer_read_covers_range'
-                : 'newer_snapshot',
-        supersededByToolCallId: replacement.toolCallId,
-        ...(observation.isError ? { failureBodySha256: observation.bodySha256 } : {}),
-    };
-}
-function exactObservationKey(observation) {
-    return `${observation.toolName}\u0000${stableStringify(observation.input)}\u0000${observation.isError ? 'error' : 'success'}\u0000${observation.bodySha256}`;
-}
-function describeObservation(toolName, input) {
-    if (toolName === 'Read')
-        return describeRead(input);
-    if (toolName === 'Glob')
-        return describeGlob(input);
-    if (toolName === 'Grep')
-        return describeGrep(input);
-    if (toolName === 'Bash')
-        return describeBash(input);
-    return undefined;
-}
-function describeRead(input) {
-    const record = asRecord(input);
-    if (!record || typeof record.path !== 'string' || record.path.length === 0) {
-        return undefined;
-    }
-    const start = nonNegativeInteger(record.offset) ?? 0;
-    const limit = positiveInteger(record.limit);
-    return {
-        kind: 'read',
-        path: normalizeSubjectPath(record.path),
-        start,
-        end: limit === undefined ? Number.POSITIVE_INFINITY : start + limit,
-    };
-}
-function describeGlob(input) {
-    const record = asRecord(input);
-    if (!record || typeof record.pattern !== 'string')
-        return undefined;
-    if (record.cwd !== undefined && typeof record.cwd !== 'string')
-        return undefined;
-    return {
-        kind: 'snapshot',
-        key: `Glob\u0000${stableStringify({
-            pattern: record.pattern,
-            cwd: normalizeSubjectPath(record.cwd ?? '.'),
-        })}`,
-    };
-}
-function describeGrep(input) {
-    const record = asRecord(input);
-    if (!record || typeof record.pattern !== 'string')
-        return undefined;
-    if (record.path !== undefined && typeof record.path !== 'string')
-        return undefined;
-    if (record.glob !== undefined && typeof record.glob !== 'string')
-        return undefined;
-    return {
-        kind: 'snapshot',
-        key: `Grep\u0000${stableStringify({
-            pattern: record.pattern,
-            path: normalizeSubjectPath(record.path ?? '.'),
-            glob: record.glob ?? null,
-        })}`,
-    };
-}
-function describeBash(input) {
-    const record = asRecord(input);
-    if (!record || typeof record.command !== 'string')
-        return undefined;
-    if ((record.run_in_background !== undefined && typeof record.run_in_background !== 'boolean') ||
-        (record.pty !== undefined && typeof record.pty !== 'boolean')) {
-        return undefined;
-    }
-    // Background and PTY results are process handles or terminal snapshots, not
-    // newer observations of a foreground command. Keep each one independently
-    // visible; exact input-and-output deduplication still handles true repeats.
-    if (record.run_in_background === true || record.pty === true)
-        return undefined;
-    const command = record.command.trim();
-    if (!isSupportedGitSnapshotCommand(command))
-        return undefined;
-    return { kind: 'snapshot', key: `Bash\u0000${command}` };
-}
-function isSupportedGitSnapshotCommand(command) {
-    if (command.length === 0 || /[;&|<>`\n\r]/.test(command) || command.includes('$('))
-        return false;
-    // Executable test/build output is evidence from a particular run, not a
-    // snapshot of current state: an incremental rerun can omit an earlier
-    // warning, and a passing rerun must not erase a flaky failure. Those calls
-    // remain eligible for exact input-and-output deduplication only.
-    return /^git(?:\s+-C\s+\S+)?\s+(?:status|diff|log|show|branch|rev-parse)(?:\s|$)/.test(command);
-}
-function readCovers(candidate, original) {
-    return candidate.start <= original.start && candidate.end >= original.end;
-}
-function normalizeSubjectPath(value) {
-    // Keep identity lexical and platform-independent. Leading whitespace and
-    // backslashes are valid POSIX filename characters, repeated leading slashes
-    // can carry implementation-defined meaning, and a Windows UNC prefix must
-    // not collapse into a POSIX-looking path. Removing an explicit leading `./`
-    // segment is the only equivalence shared by the supported executors. Prefer
-    // false negatives here: semantic supersession must never merge distinct
-    // filesystem subjects.
-    let normalized = value;
-    while (normalized.startsWith('./'))
-        normalized = normalized.slice(2);
-    return normalized.length === 0 ? '.' : normalized;
-}
-function asRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function nonNegativeInteger(value) {
-    return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : undefined;
-}
-function positiveInteger(value) {
-    return typeof value === 'number' && Number.isInteger(value) && value > 0 ? value : undefined;
-}
-function stableStringify(value) {
-    if (value === undefined)
-        return '';
-    if (value === null || typeof value !== 'object')
-        return JSON.stringify(value) ?? '';
-    if (Array.isArray(value))
-        return `[${value.map(stableStringify).join(',')}]`;
-    const record = value;
-    return `{${Object.keys(record)
-        .sort()
-        .map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`)
-        .join(',')}}`;
-}

package/node_modules/@maka/runtime/dist/archive-read-tool.js

@@ -1,115 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-import { jsonSchema, zodSchema } from 'ai';
-import { z } from 'zod';
-import { readToolResultArchiveResource, TOOL_RESULT_ARCHIVE_MAX_LIMIT, } from './tool-result-archive-resource.js';
-export const ARCHIVE_READ_TOOL_NAME = 'ArchiveRead';
-export function buildArchiveReadTool(reader) {
-    const parameters = z.preprocess(cleanArchiveReadInput, z
-        .object({
-        ref: z
-            .string()
-            .describe('The exact resourceRef returned in an archived tool-result placeholder (ledger or legacy archive)'),
-        operation: z
-            .enum(['inspect', 'read', 'query', 'search'])
-            .default('inspect')
-            .describe('inspect lists archive metadata/items and a preview; query reads one structured item; read returns one bounded page (by character or line); search locates a substring'),
-        unit: z
-            .enum(['char', 'line'])
-            .default('char')
-            .describe('For read: whether offset/limit count characters (default) or whole lines'),
-        offset: z
-            .number()
-            .int()
-            .nonnegative()
-            .optional()
-            .describe('Zero-based start for pagination: character or line offset for read (per unit), character offset for query, or the character position to resume search from'),
-        limit: z
-            .number()
-            .int()
-            .positive()
-            .max(TOOL_RESULT_ARCHIVE_MAX_LIMIT)
-            .optional()
-            .describe(`Maximum returned characters (or lines when unit is "line"), capped at ${TOOL_RESULT_ARCHIVE_MAX_LIMIT}`),
-        itemId: z
-            .string()
-            .min(1)
-            .max(256)
-            .optional()
-            .describe('Structured item id returned by inspect; required for query'),
-        pattern: z
-            .string()
-            .min(1)
-            .max(256)
-            .optional()
-            .describe('Literal, case-insensitive substring to locate; required for search'),
-    })
-        .strip()
-        .superRefine((value, ctx) => {
-        if (value.operation === 'query' && !value.itemId) {
-            ctx.addIssue({
-                code: 'custom',
-                path: ['itemId'],
-                message: 'itemId is required for query',
-            });
-        }
-        if (value.operation === 'search' && !value.pattern) {
-            ctx.addIssue({
-                code: 'custom',
-                path: ['pattern'],
-                message: 'pattern is required for search',
-            });
-        }
-    }));
-    const providerSchema = zodSchema(parameters);
-    return {
-        name: ARCHIVE_READ_TOOL_NAME,
-        displayName: 'Read archived result',
-        activityKind: 'read',
-        description: 'Inspect, search, or page through a tool-result archive using its exact resourceRef. Both ledger and legacy archive references are supported. Start with inspect for a preview and the char/line coordinate space. Use operation "search" with a pattern to locate text, operation "read" with unit "line" for line-oriented terminal output, or operation "query" with an itemId for one agent_swarm item. Results are strictly bounded so reading an archive cannot immediately trigger another archive.',
-        parameters: jsonSchema(async () => await providerSchema.jsonSchema, {
-            validate: async (value) => {
-                const result = await parameters.safeParseAsync(value);
-                return result.success
-                    ? { success: true, value: result.data }
-                    : { success: false, error: result.error };
-            },
-        }),
-        impl: async (input, ctx) => 
-        // Detach bounded slices before active tool settlements retain their archive backing.
-        structuredClone(await readToolResultArchiveResource(reader, ctx.sessionId, input, ctx.abortSignal)),
-    };
-}
-function cleanArchiveReadInput(input) {
-    if (!input || typeof input !== 'object' || Array.isArray(input))
-        return input;
-    const cleaned = { ...input };
-    const operation = cleaned.operation ?? 'inspect';
-    if (operation !== 'query')
-        delete cleaned.itemId;
-    if (operation !== 'search')
-        delete cleaned.pattern;
-    if (operation !== 'read')
-        delete cleaned.unit;
-    if (operation === 'inspect') {
-        delete cleaned.offset;
-        delete cleaned.limit;
-    }
-    return cleaned;
-}