@zq-silk/yui 2.0.0 → 2.2.0

package/dist/nativeAgent/executionOwner.js

@@ -0,0 +1,209 @@
+import { randomUUID } from 'node:crypto';
+import { ContextBuildError } from './context/index.js';
+/** One local execution owner per Session. Storage remains the sole history
+ * authority; this object owns only live handles and current-process receipts.
+ * The explicit catalog is a selection view, not persistent Session discovery. */
+export function createExecutionOwner(options) {
+    if (!Number.isSafeInteger(options.maxSteps) || options.maxSteps < 1)
+        throw new Error('Positive maxSteps required');
+    const catalog = new Map((options.sessions ?? []).map(item => [item.id, { ...item }]));
+    const active = new Map();
+    const completed = new Map();
+    const compacting = new Map();
+    const listeners = new Map();
+    const subscriptions = new Set();
+    let closed = false;
+    const check = () => { if (closed)
+        throw new Error('Execution owner closed'); };
+    const notify = (id) => {
+        for (const listener of listeners.get(id) ?? []) {
+            try {
+                void Promise.resolve(listener()).catch(() => { });
+            }
+            catch { /* Invalidation is optional. */ }
+        }
+    };
+    const bounds = (offset, limit, length) => {
+        if (!Number.isSafeInteger(offset) || offset < 0 || (length !== undefined && offset > length)
+            || !Number.isInteger(limit) || limit < 1 || limit > 20)
+            throw new Error('Invalid page bounds');
+    };
+    return {
+        async create(title, location) {
+            check();
+            const summary = { id: randomUUID(), title: title.slice(0, 200) };
+            await options.store.create(summary.id, location);
+            catalog.set(summary.id, summary);
+            return { ...summary };
+        },
+        async list(offset, limit) {
+            check();
+            bounds(offset, limit, catalog.size);
+            return { sessions: [...catalog.values()].slice(offset, offset + limit).map(item => ({ ...item })),
+                nextOffset: offset + limit < catalog.size ? offset + limit : null };
+        },
+        async submit(sessionId, input) {
+            check();
+            if (active.has(sessionId) || compacting.has(sessionId))
+                throw new Error('Session already running or compacting');
+            if (completed.get(sessionId)?.result?.recording.status === 'failed' || completed.get(sessionId)?.failure)
+                throw new Error('Prior execution requires explicit inspection; no automatic retry');
+            const scope = Object.freeze({ sessionId, turnId: randomUUID() });
+            const abort = new AbortController();
+            let accept, reject;
+            const accepted = new Promise((resolve, fail) => { accept = resolve; reject = fail; });
+            // Install the handle before loading history or acquiring a recorder.
+            const done = Promise.resolve().then(async () => {
+                let recording;
+                let evidence = { scope };
+                try {
+                    const saved = await options.store.load(sessionId);
+                    recording = await options.store.recorder(sessionId);
+                    // A concurrent outside writer is unsupported; never mix two revisions.
+                    if (recording.lastReceipt.revision !== saved.revision)
+                        throw new Error('Session changed during admission');
+                    check();
+                    const agent = await options.agent(recording);
+                    check(); // Async admission must not acknowledge execution after close.
+                    accept();
+                    const result = await agent.runTurn({ ...scope, input, history: saved.messages,
+                        maxSteps: options.maxSteps, signal: abort.signal,
+                        context: { ...options.context?.retention, baseReceipt: { sessionId, revision: saved.revision, digest: saved.digest,
+                                messageCount: saved.messages.length } } });
+                    evidence = { scope, result, receipt: recording.lastReceipt,
+                        ...(recording.failure ? { failure: recording.failure } : {}) };
+                    // A returned result is live evidence, not a reconstituted persisted result.
+                    try {
+                        options.observer?.observeSnapshot(result);
+                    }
+                    catch { /* Optional diagnostics. */ }
+                }
+                catch (failure) {
+                    reject(failure);
+                    evidence = { scope, ...(recording ? { receipt: recording.lastReceipt } : {}), failure };
+                }
+                finally {
+                    completed.set(sessionId, evidence);
+                    active.delete(sessionId);
+                    notify(sessionId);
+                }
+                return evidence;
+            });
+            active.set(sessionId, { scope, abort, done });
+            notify(sessionId);
+            await accepted;
+            return scope;
+        },
+        async cancel(scope) {
+            const turn = active.get(scope.sessionId);
+            if (!turn || turn.scope.turnId !== scope.turnId)
+                return false;
+            turn.abort.abort();
+            return true;
+        },
+        async read(id, after, limit) {
+            check();
+            bounds(after, limit);
+            const page = await options.store.query(id, { after, limit });
+            const diagnostic = completed.get(id)?.failure ? 'Recording/execution failed; inspect owner evidence and saved facts; no automatic retry'
+                : (await options.store.load(id)).recovery.disposition !== 'ready' && !active.has(id)
+                    ? 'Saved execution needs explicit recovery; not evidence of a live Turn' : undefined;
+            return {
+                records: page.records.map(({ revision, event }) => ({ cursor: revision, kind: 'event', event })),
+                cursor: page.records.at(-1)?.revision ?? after, hasMore: page.nextCursor !== null,
+                activeTurnId: active.get(id)?.scope.turnId ?? null, ...(diagnostic ? { diagnostic } : {}),
+            };
+        },
+        async history(id, offset, limit) {
+            check();
+            const saved = await options.store.load(id);
+            bounds(offset, limit, saved.messages.length);
+            return { messages: saved.messages.slice(offset, offset + limit),
+                nextOffset: offset + limit < saved.messages.length ? offset + limit : null };
+        },
+        subscribe(id, listener) {
+            check();
+            let group = listeners.get(id);
+            if (!group) {
+                group = new Set();
+                listeners.set(id, group);
+            }
+            group.add(listener);
+            const detach = options.store.subscribe(id, () => {
+                try {
+                    void Promise.resolve(listener()).catch(() => { });
+                }
+                catch { /* Optional invalidation. */ }
+            });
+            const unsubscribe = () => { detach(); group.delete(listener); subscriptions.delete(unsubscribe); };
+            subscriptions.add(unsubscribe);
+            return unsubscribe;
+        },
+        async settle(id) { return active.get(id)?.done ?? completed.get(id); },
+        async compact(sessionId, signal) {
+            check();
+            if (!options.context)
+                throw new ContextBuildError('invalid_options', 'Manual context builder is not configured');
+            if (active.has(sessionId) || compacting.has(sessionId))
+                throw new ContextBuildError('session_busy', 'Settle the active Turn/compaction before a manual projection');
+            if (completed.get(sessionId)?.failure || completed.get(sessionId)?.result?.recording.status === 'failed')
+                throw new ContextBuildError('storage_failed', 'Inspect prior owner/storage evidence before compacting');
+            const config = options.context;
+            const abort = new AbortController();
+            const cancel = () => abort.abort();
+            signal?.addEventListener('abort', cancel, { once: true });
+            if (signal?.aborted)
+                cancel();
+            const load = async () => {
+                try {
+                    return await options.store.load(sessionId);
+                }
+                catch (error) {
+                    const failure = new ContextBuildError('storage_failed', 'Manual projection could not read/verify the authoritative SessionStore');
+                    failure.cause = error;
+                    throw failure;
+                }
+            };
+            const done = Promise.resolve().then(async () => {
+                const saved = await load();
+                if (saved.recovery.disposition !== 'ready')
+                    throw new ContextBuildError('session_recovery_required', 'Inspect unresolved effects, cleanup and interrupted facts before compacting');
+                const built = await config.builder.build({ ...config.retention, mode: 'manual', budget: config.budget,
+                    baseReceipt: { sessionId, revision: saved.revision, digest: saved.digest, messageCount: saved.messages.length },
+                    request: { sessionId, turnId: `projection:${randomUUID()}`, step: 1, tools: config.tools,
+                        messages: saved.messages } }, abort.signal);
+                const current = await load();
+                if (current.digest !== saved.digest || current.revision !== saved.revision)
+                    throw new ContextBuildError('history_changed', 'Stored history changed during manual projection; reload exact current facts');
+                if (abort.signal.aborted)
+                    throw new ContextBuildError('cancelled', 'Manual projection cancelled; no history changed');
+                return { ...built, receipt: { sessionId, revision: saved.revision, digest: saved.digest, source: saved.source } };
+            }).catch(error => {
+                config.builder.discard?.(sessionId);
+                throw error;
+            }).finally(() => {
+                compacting.delete(sessionId);
+                signal?.removeEventListener('abort', cancel);
+            });
+            compacting.set(sessionId, { abort, done });
+            return done;
+        },
+        getSettledEvidence(scope) {
+            const evidence = completed.get(scope.sessionId);
+            return evidence?.scope.turnId === scope.turnId ? evidence : undefined;
+        },
+        async close() {
+            closed = true;
+            const owned = [...active.values()];
+            const projections = [...compacting.values()];
+            for (const turn of owned)
+                turn.abort.abort();
+            for (const projection of projections)
+                projection.abort.abort();
+            await Promise.allSettled([...owned.map(turn => turn.done), ...projections.map(projection => projection.done)]);
+            for (const unsubscribe of subscriptions)
+                unsubscribe();
+            listeners.clear();
+        },
+    };
+}

package/dist/nativeAgent/filePatterns.js

@@ -0,0 +1,170 @@
+import { FileFault } from './fileToolsSupport.js';
+const tick = (budget) => {
+    if (--budget.remaining < 0)
+        throw new FileFault('pattern_limit', 'Pattern matching work budget exceeded; narrow scope/pattern');
+};
+const unsupported = () => { throw new FileFault('unsupported_pattern', 'Unsupported pattern syntax; see repository-tool grammar'); };
+function characterClass(pattern, start, globClass = false) {
+    let end = start + 1;
+    const negative = pattern[end] === '^' || (globClass && pattern[end] === '!');
+    if (negative)
+        end++;
+    const ranges = [];
+    while (end < pattern.length && pattern[end] !== ']') {
+        const first = String.fromCodePoint(pattern.codePointAt(end));
+        end += first.length;
+        if (first === '\\' || first === '[')
+            unsupported();
+        let last = first;
+        if (pattern[end] === '-' && pattern[end + 1] !== ']') {
+            end++;
+            if (end >= pattern.length)
+                unsupported();
+            last = String.fromCodePoint(pattern.codePointAt(end));
+            end += last.length;
+            if (last.codePointAt(0) < first.codePointAt(0))
+                unsupported();
+        }
+        ranges.push([first.codePointAt(0), last.codePointAt(0)]);
+    }
+    if (pattern[end] !== ']' || !ranges.length)
+        unsupported();
+    return { test: ch => negative !== ranges.some(([first, last]) => ch.codePointAt(0) >= first && ch.codePointAt(0) <= last), end };
+}
+function boundedPattern(pattern) {
+    if (!pattern || pattern.length > 256 || /[\0\r\n]/.test(pattern))
+        unsupported();
+}
+function sequence(atoms, text, budget, startAnchor = true, endAnchor = true) {
+    let active = new Uint8Array(atoms.length + 1);
+    active[0] = 1;
+    const closure = (states) => {
+        for (let i = 0; i < atoms.length; i++) {
+            tick(budget);
+            if (states[i] && atoms[i].optional)
+                states[i + 1] = 1;
+        }
+    };
+    closure(active);
+    if (!endAnchor && active[atoms.length])
+        return true;
+    for (const ch of text) {
+        const next = new Uint8Array(atoms.length + 1);
+        if (!startAnchor)
+            next[0] = 1;
+        for (let i = 0; i < atoms.length; i++) {
+            tick(budget);
+            if (active[i] && atoms[i].test(ch)) {
+                next[i + 1] = 1;
+                if (atoms[i].repeat)
+                    next[i] = 1;
+            }
+        }
+        closure(next);
+        active = next;
+        if (!endAnchor && active[atoms.length])
+            return true;
+    }
+    return !!active[atoms.length];
+}
+/** *, ?, classes, backslash literal escapes; ** is only a complete path segment. */
+export function glob(pattern) {
+    boundedPattern(pattern);
+    const segments = pattern.split('/').map(segment => {
+        if (segment === '**')
+            return null;
+        const atoms = [];
+        for (let i = 0; i < segment.length; i++) {
+            const ch = String.fromCodePoint(segment.codePointAt(i));
+            if ('@+?!*'.includes(ch) && segment[i + 1] === '(')
+                unsupported();
+            if (ch === '*' && segment[i + 1] === '*')
+                unsupported();
+            if (ch === '*')
+                atoms.push({ test: () => true, repeat: true, optional: true });
+            else if (ch === '?')
+                atoms.push({ test: () => true, repeat: false, optional: false });
+            else if (ch === '[') {
+                const cls = characterClass(segment, i, true);
+                i = cls.end;
+                atoms.push({ test: cls.test, repeat: false, optional: false });
+            }
+            else {
+                if (ch === '\\' && ++i >= segment.length)
+                    unsupported();
+                const literal = ch === '\\' ? String.fromCodePoint(segment.codePointAt(i)) : ch;
+                if (ch !== '\\' && '{}]'.includes(literal))
+                    unsupported();
+                i += literal.length - 1;
+                atoms.push({ test: value => value === literal, repeat: false, optional: false });
+            }
+        }
+        return atoms;
+    });
+    return (text, budget) => {
+        const parts = text.split('/');
+        let active = new Uint8Array(parts.length + 1);
+        active[0] = 1;
+        for (const segment of segments) {
+            const next = new Uint8Array(parts.length + 1);
+            for (let j = 0; j <= parts.length; j++) {
+                tick(budget);
+                if (segment === null) {
+                    if (active[j] || (j > 0 && next[j - 1]))
+                        next[j] = 1;
+                }
+                else if (j < parts.length && active[j] && sequence(segment, parts[j], budget))
+                    next[j + 1] = 1;
+            }
+            active = next;
+        }
+        return !!active[parts.length];
+    };
+}
+/** Single-line regex: literals, . classes, ^ $, escapes, * + ?. No groups/alternation/counts/lookaround/backrefs. */
+export function regex(pattern) {
+    boundedPattern(pattern);
+    const startAnchor = pattern.startsWith('^');
+    let endAnchor = false;
+    const atoms = [];
+    for (let i = startAnchor ? 1 : 0; i < pattern.length; i++) {
+        const ch = String.fromCodePoint(pattern.codePointAt(i));
+        if (ch === '$' && i === pattern.length - 1) {
+            endAnchor = true;
+            break;
+        }
+        let test = () => false;
+        if (ch === '.')
+            test = () => true;
+        else if (ch === '[') {
+            const cls = characterClass(pattern, i);
+            test = cls.test;
+            i = cls.end;
+        }
+        else if (ch === '\\') {
+            const escaped = pattern[++i] ?? unsupported();
+            if (/[0-9]/.test(escaped))
+                unsupported();
+            if (escaped === 'd')
+                test = value => value >= '0' && value <= '9';
+            else if (escaped === 'w')
+                test = value => /^[A-Za-z0-9_]$/.test(value);
+            else if (escaped === 's')
+                test = value => /^\s$/.test(value);
+            else if ('\\.^$*+?[](){}|'.includes(escaped))
+                test = value => value === escaped;
+            else
+                unsupported();
+        }
+        else {
+            if ('^$*+?(){}|]'.includes(ch))
+                unsupported();
+            test = value => value === ch;
+        }
+        if (ch.length > 1)
+            i += ch.length - 1;
+        const quantifier = '*+?'.includes(pattern[i + 1] ?? '\0') ? pattern[++i] : '';
+        atoms.push({ test, repeat: quantifier === '*' || quantifier === '+', optional: quantifier === '*' || quantifier === '?' });
+    }
+    return (text, budget) => sequence(atoms, text, budget, startAnchor, endAnchor);
+}

package/dist/nativeAgent/fileToolsSupport.js

@@ -0,0 +1,202 @@
+import { constants, realpathSync, statSync } from 'node:fs';
+import { lstat, open } from 'node:fs/promises';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+// Private repository-pack helpers. These checks are not an adversarial sandbox.
+export class FileFault extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+export const digest = (text) => createHash('sha256').update(text).digest('hex');
+export function bounded(value, maximum, label) {
+    const result = value ?? maximum;
+    if (!Number.isSafeInteger(result) || result < 1 || result > maximum)
+        throw new Error(`${label} must be in [1, ${maximum}]`);
+    return result;
+}
+export function workspaceRoot(root) {
+    if (!path.isAbsolute(root))
+        throw new Error('An explicit absolute workspace root is required');
+    const result = realpathSync(root);
+    if (!statSync(result).isDirectory())
+        throw new Error('Workspace must be a directory');
+    return result;
+}
+export function validPath(relative) {
+    return typeof relative === 'string' && !!relative.trim() && Buffer.byteLength(relative) <= 4096
+        && !/[\0\r\n]/.test(relative) && !path.isAbsolute(relative) && !relative.split(/[\\/]/).includes('..');
+}
+export async function inspect(target) {
+    const info = await lstat(target);
+    if (info.isSymbolicLink())
+        throw new FileFault('symlink_denied', 'Symlinks are not allowed');
+    if (!info.isDirectory() && (!info.isFile() || info.nlink !== 1))
+        throw new FileFault('not_regular_file', 'Expected directories or single-link files');
+    return info;
+}
+export async function checkPath(root, relative, allowMissing = false) {
+    if (!validPath(relative))
+        throw new FileFault('path_out_of_scope', 'Expected a relative path without parent traversal');
+    const target = path.resolve(root, relative);
+    const parts = path.relative(root, target).split(path.sep).filter(Boolean);
+    let current = root;
+    if (!(await inspect(root)).isDirectory())
+        throw new FileFault('not_directory', 'Workspace is not a directory');
+    for (let i = 0; i < parts.length; i++) {
+        current = path.join(current, parts[i]);
+        let info;
+        try {
+            info = await inspect(current);
+        }
+        catch (error) {
+            if (allowMissing && i === parts.length - 1 && error.code === 'ENOENT')
+                return target;
+            throw error;
+        }
+        if (i < parts.length - 1 && !info.isDirectory())
+            throw new FileFault('not_directory', 'Expected ordinary directories');
+    }
+    return target;
+}
+// Shared, deliberately narrow binary classification; not general format detection.
+export const isBinary = (text) => text.includes('\0');
+export function assertText(text) {
+    if (isBinary(text))
+        throw new FileFault('binary_file', 'NUL-bearing binary content is not supported by text tools');
+}
+export async function readSnapshot(target, maxBytes, signal) {
+    const file = await open(target, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    try {
+        const before = await file.stat({ bigint: true });
+        const identity = (info) => `${info.dev}:${info.ino}:${info.size}:${info.mtimeNs}:${info.ctimeNs}`;
+        if (!before.isFile() || before.nlink !== 1n)
+            throw new FileFault('not_regular_file', 'Expected single-link regular file');
+        if (before.size > maxBytes)
+            throw new FileFault('too_large', 'File exceeds scan byte limit');
+        const buffer = Buffer.alloc(Math.min(Number(before.size) + 1, maxBytes + 1));
+        let bytes = 0;
+        while (bytes < buffer.length) {
+            signal.throwIfAborted();
+            const read = await file.read(buffer, bytes, buffer.length - bytes, bytes);
+            if (!read.bytesRead)
+                break;
+            bytes += read.bytesRead;
+        }
+        const after = await file.stat({ bigint: true });
+        if (bytes > maxBytes)
+            throw new FileFault('too_large', 'File exceeds scan byte limit');
+        if (identity(before) !== identity(after) || BigInt(bytes) !== before.size)
+            throw new FileFault('edit_conflict', 'File changed while reading');
+        const raw = buffer.subarray(0, bytes);
+        let text;
+        try {
+            text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(raw);
+        }
+        catch {
+            throw new FileFault('invalid_utf8', 'File is not valid UTF-8');
+        }
+        return { text, bytes, sha256: digest(raw), identity: identity(after) };
+    }
+    finally {
+        await file.close();
+    }
+}
+// Include the escaped inner JSON in the outer outcome and ToolManager's message.
+export function fits(outcome, maximum, name, toolCallId) {
+    return Buffer.byteLength(JSON.stringify(outcome)) <= maximum
+        && Buffer.byteLength(JSON.stringify({ role: 'tool', name, toolCallId, outcome })) <= 512 * 1024;
+}
+export function cursor(binding, fingerprint, offset) {
+    return Buffer.from(JSON.stringify({ v: 1, binding, fingerprint, offset })).toString('base64url');
+}
+export function readCursor(value, binding, fingerprint, maximum) {
+    if (!value)
+        return 0;
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+    }
+    catch {
+        throw new FileFault('invalid_cursor', 'Cursor cannot be decoded');
+    }
+    if (!parsed || parsed.v !== 1 || parsed.binding !== binding || !Number.isSafeInteger(parsed.offset)
+        || parsed.offset < 0 || parsed.offset > maximum)
+        throw new FileFault('invalid_cursor', 'Cursor does not match request');
+    if (parsed.fingerprint !== fingerprint)
+        throw new FileFault('stale_cursor', 'Files or coverage changed; restart query');
+    return parsed.offset;
+}
+export const lines = (text) => text.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+export function replace(text, edits) {
+    let result = text;
+    for (const edit of [...edits].reverse())
+        result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+    return result;
+}
+// Git's quoted paths use C escapes, not JSON's \uXXXX. Keep UTF-8 literal;
+// three-digit octal escapes avoid ambiguity with following filename digits.
+function quoteDiffPath(value) {
+    return '"' + value.replace(/[\x00-\x1f\x7f"\\]/g, character => {
+        if (character === '"' || character === '\\')
+            return '\\' + character;
+        return '\\' + character.charCodeAt(0).toString(8).padStart(3, '0');
+    }) + '"';
+}
+/** Edit-derived hunks, not a quadratic whole-file diff or a Git HEAD diff. */
+export function diff(relative, before, edits, next, creating = false) {
+    if (before === next && !creating)
+        return '';
+    if (creating && !next)
+        return `diff --git ${quoteDiffPath(`a/${relative}`)} ${quoteDiffPath(`b/${relative}`)}\nnew file mode 100600\n`;
+    const oldLines = lines(before);
+    const starts = [0];
+    for (const line of oldLines)
+        starts.push(starts[starts.length - 1] + line.length);
+    const groups = [];
+    for (const edit of edits) {
+        let first = 0;
+        while (first < oldLines.length && starts[first + 1] <= edit.start)
+            first++;
+        let last = first;
+        while (last < oldLines.length && starts[last] < edit.end)
+            last++;
+        const group = { start: Math.max(0, first - 3), end: Math.min(oldLines.length, Math.max(first + 1, last) + 3) };
+        const previous = groups[groups.length - 1];
+        if (previous && group.start <= previous.end)
+            previous.end = Math.max(previous.end, group.end);
+        else
+            groups.push(group);
+    }
+    let output = `--- ${creating ? '/dev/null' : quoteDiffPath(`a/${relative}`)}\n+++ ${quoteDiffPath(`b/${relative}`)}\n`;
+    let lineDelta = 0;
+    const print = (prefix, line) => prefix + line + (line.endsWith('\n') ? '' : '\n\\n');
+    for (const group of groups) {
+        const start = starts[group.start];
+        const end = starts[group.end];
+        const local = edits.filter(edit => edit.start >= start && edit.end <= end)
+            .map(edit => ({ ...edit, start: edit.start - start, end: edit.end - start }));
+        const old = oldLines.slice(group.start, group.end);
+        const updated = lines(replace(before.slice(start, end), local));
+        let prefix = 0;
+        while (prefix < old.length && prefix < updated.length && old[prefix] === updated[prefix])
+            prefix++;
+        let suffix = 0;
+        while (suffix < old.length - prefix && suffix < updated.length - prefix
+            && old[old.length - 1 - suffix] === updated[updated.length - 1 - suffix])
+            suffix++;
+        output += `@@ -${old.length ? group.start + 1 : group.start},${old.length} +${updated.length ? group.start + lineDelta + 1 : group.start + lineDelta},${updated.length} @@\n`;
+        for (const line of old.slice(0, prefix))
+            output += print(' ', line);
+        for (const line of old.slice(prefix, old.length - suffix))
+            output += print('-', line);
+        for (const line of updated.slice(prefix, updated.length - suffix))
+            output += print('+', line);
+        for (const line of old.slice(old.length - suffix))
+            output += print(' ', line);
+        lineDelta += updated.length - old.length;
+    }
+    return output;
+}

package/dist/nativeAgent/index.js

@@ -0,0 +1,16 @@
+export { createAgent } from './agent.js';
+export { createToolExecutor } from './toolManager/index.js';
+export { createContextBuilder, createProviderCompressor, ContextBuildError, jsonByteEstimator } from './context/index.js';
+export { createProjectGuidance } from './projectGuidance/index.js';
+export { createLocalObserver } from './observability/index.js';
+export { createModelGateway, createChatCompletionsAdapter, createResponsesAdapter, createAnthropicMessagesAdapter, createProtocolAdapter, getProtocolCapabilities, createModelObservationAdapter, ModelGatewayError } from './model/index.js';
+export { openCli, createTextRenderer } from './interaction/index.js';
+export { connectModelObservations, createInteractionDiagnostics, createInteractionProgress } from './composition.js';
+export { createSessionStore, createMemorySessionBackend, createSqliteSessionBackend, SessionError, SessionMetadataSaveError, catalogLimits, locationLimits, } from './session/index.js';
+export { createExecutionOwner } from './executionOwner.js';
+export { createMockProvider } from './mockProvider.js';
+export { createTextTools } from './textTools.js';
+export { createSearchTools } from './searchTools.js';
+export { createCommandTool } from './commandTool.js';
+export { createCodingTools } from './codingTools.js';
+export { createLocalToolBinding } from './localSafety.js';