@myagentroam/agent 0.11.33 → 0.11.34

package/dist/agent-core/model/product-user-agent.d.ts

@@ -1,5 +0,0 @@
-/**
- * Product identity sent to upstream model endpoints. Runtime credential headers may
- * override this value per request.
- */
-export declare function productUserAgent(): string;

package/dist/agent-core/model/product-user-agent.js

@@ -1,22 +0,0 @@
-import { readFileSync } from 'node:fs';
-let cachedUserAgent;
-/**
- * Product identity sent to upstream model endpoints. Runtime credential headers may
- * override this value per request.
- */
-export function productUserAgent() {
-    cachedUserAgent ??= resolveProductUserAgent();
-    return cachedUserAgent;
-}
-function resolveProductUserAgent() {
-    try {
-        const raw = readFileSync(new URL('../../../package.json', import.meta.url), 'utf8');
-        const version = JSON.parse(raw).version;
-        if (typeof version === 'string' && version.length > 0 && version.length <= 64)
-            return 'MyAgentRoam/' + version + ' (' + process.platform + '; ' + process.arch + ')';
-    }
-    catch {
-        // Fall through to the identity-preserving fallback below.
-    }
-    return 'MyAgentRoam/unknown (' + process.platform + '; ' + process.arch + ')';
-}

package/dist/agent-core/model/recovery.js

@@ -1,80 +0,0 @@
-import { MarAgentError } from '../error.js';
-import { isAnthropicRecoverableStreamError } from './anthropic-messages.js';
-import { isRetryableModelRequestError, modelRetryMaxAttempts, waitForModelRetry } from './http.js';
-import { isOpenAiResponsesRecoverableStreamError } from './openai-responses.js';
-/** Retry only classified recoverable failures within the attempt budget; never retry cancellation. */
-export async function recoverModelStream(error, retryState, signal) {
-    if (signal.aborted ||
-        !((error instanceof MarAgentError &&
-            error.code === 'MAR_AGENT_MODEL_OUTPUT_INCOMPLETE' &&
-            error.retryable) ||
-            isRetryableModelRequestError(error) ||
-            isOpenAiResponsesRecoverableStreamError(error) ||
-            isAnthropicRecoverableStreamError(error)) ||
-        retryState.attempts >= modelRetryMaxAttempts(retryState))
-        return false;
-    const delayMs = retryState.retryDelayMs;
-    delete retryState.retryDelayMs;
-    try {
-        await waitForModelRetry(typeof error.details?.retryAfter === 'string' ? error.details.retryAfter : null, retryState.attempts - 1, signal, delayMs);
-    }
-    catch (error) {
-        signal.throwIfAborted();
-        throw error;
-    }
-    return true;
-}
-const PROVIDER_CONTEXT_OVERFLOW_CODES = new Set([
-    'mar_agent_context_limit',
-    'context_length_exceeded',
-    'context_overflow',
-    'context_window_exceeded',
-    'prompt_too_long',
-    'request_too_large',
-    'string_above_max_length'
-]);
-const PROVIDER_CONTEXT_OVERFLOW_PATTERNS = [
-    /prompt is too long/iu,
-    /request_too_large/iu,
-    /input is too long for requested model/iu,
-    /exceeds (?:the )?(?:model'?s )?(?:maximum )?context (?:length|window)/iu,
-    /input token count.*exceeds the maximum/iu,
-    /tokens in request more than max tokens allowed/iu,
-    /maximum prompt length is \d+/iu,
-    /reduce the length of the messages/iu,
-    /maximum context length is \d+ tokens/iu,
-    /exceeds (?:the )?maximum allowed input length/iu,
-    /greater than the context length/iu,
-    /context window exceeds limit/iu,
-    /exceeded model token limit/iu,
-    /context[_ ]length[_ ]exceeded/iu,
-    /request entity too large/iu,
-    /input length.*exceeds.*context length/iu,
-    /prompt too long; exceeded (?:max )?context length/iu,
-    /model_context_window_exceeded/iu,
-    /too many tokens/iu,
-    /token limit exceeded/iu
-];
-const PROVIDER_CONTEXT_OVERFLOW_EXCLUSIONS = [
-    /^(?:[^:]+: )?(?:throttling error|service unavailable):/iu,
-    /rate limit/iu,
-    /too many requests/iu
-];
-export function isProviderContextOverflow(error) {
-    if (!(error instanceof MarAgentError))
-        return false;
-    const code = error.code.trim().toLowerCase();
-    if (PROVIDER_CONTEXT_OVERFLOW_CODES.has(code))
-        return true;
-    if (error.details?.status === 413)
-        return true;
-    const message = error.message;
-    // K3-compatible gateways report context overflow as HTTP 401 instead of a
-    // standard provider error code. Keep this exception scoped to that exact shape.
-    if (error.details?.status === 401 && /supports only [\d,.]+[km]? context/iu.test(message))
-        return true;
-    if (code !== 'invalid_request_error' && code !== 'mar_agent_model_protocol_error')
-        return false;
-    return (!PROVIDER_CONTEXT_OVERFLOW_EXCLUSIONS.some((pattern) => pattern.test(message)) &&
-        PROVIDER_CONTEXT_OVERFLOW_PATTERNS.some((pattern) => pattern.test(message)));
-}

package/dist/agent-core/model/request-configuration.d.ts

@@ -1,17 +0,0 @@
-import { type MarAgentModelConfiguration, type MarAgentReasoningEffort } from './configuration.js';
-import type { ModelMessage } from './contracts.js';
-/** Resolve request effort and native updates without owning their persistence or timing. */
-export declare function prepareModelConfiguration(model: Pick<MarAgentModelConfiguration, 'id' | 'protocol' | 'responsesConfigurationUpdates' | 'codexCredential'>, effort: MarAgentReasoningEffort, context: {
-    readonly baselineEffort: MarAgentReasoningEffort | undefined;
-    readonly messages: readonly ModelMessage[];
-    readonly checkpointAdopted?: false;
-} | {
-    readonly checkpointAdopted: true;
-}): {
-    readonly requestReasoningEffort?: MarAgentReasoningEffort;
-    readonly updates: readonly ModelMessage[];
-    readonly contextProjection: {
-        readonly modelProtocol: MarAgentModelConfiguration['protocol'];
-        readonly responsesConfigurationUpdates: boolean;
-    };
-};

package/dist/agent-core/model/request-configuration.js

@@ -1,47 +0,0 @@
-import { marAgentReasoningEffortSchema, usesResponsesConfigurationUpdates } from './configuration.js';
-/** Resolve request effort and native updates without owning their persistence or timing. */
-export function prepareModelConfiguration(model, effort, context) {
-    const useUpdates = usesResponsesConfigurationUpdates(model);
-    const contextProjection = {
-        modelProtocol: model.protocol,
-        responsesConfigurationUpdates: useUpdates
-    };
-    if (context.checkpointAdopted)
-        return { requestReasoningEffort: effort, updates: [], contextProjection };
-    if (!useUpdates)
-        return { updates: [], contextProjection };
-    const requestReasoningEffort = context.baselineEffort ?? effort;
-    const effectiveEffort = context.baselineEffort === undefined
-        ? requestReasoningEffort
-        : (lastConfigurationEffort(context.messages, model.id) ?? requestReasoningEffort);
-    return {
-        requestReasoningEffort,
-        contextProjection,
-        updates: effectiveEffort === effort
-            ? []
-            : [
-                {
-                    role: 'provider',
-                    content: '',
-                    provider: 'OPENAI_RESPONSES',
-                    providerModelId: model.id,
-                    item: { type: 'configuration_update', reasoning: { effort } }
-                }
-            ]
-    };
-}
-function lastConfigurationEffort(messages, modelId) {
-    for (let index = messages.length - 1; index >= 0; index--) {
-        const message = messages[index];
-        if (message.role !== 'provider' ||
-            message.provider !== 'OPENAI_RESPONSES' ||
-            message.providerModelId !== modelId ||
-            message.item?.type !== 'configuration_update')
-            continue;
-        const reasoning = message.item.reasoning;
-        const effort = marAgentReasoningEffortSchema.safeParse(reasoning?.effort);
-        if (effort.success)
-            return effort.data;
-    }
-    return undefined;
-}

package/dist/agent-core/model/runtime-credential.d.ts

@@ -1,8 +0,0 @@
-import { SecretValue, type MarAgentModelConfiguration, type ModelCredentialProvider, type ModelCredential, type ModelCredentialAcquireReason } from './configuration.js';
-export declare function acquireModelCredential(configuration: Pick<MarAgentModelConfiguration, 'apiKey' | 'credentialProvider'> | {
-    readonly apiKey?: SecretValue;
-    readonly credentialProvider?: ModelCredentialProvider;
-}, reason: ModelCredentialAcquireReason, missingCredentialMessage: string, signal?: AbortSignal): Promise<ModelCredential>;
-export declare function appendModelCredentialHeaders(headers: Headers, credential: ModelCredential, reservedHeaders: ReadonlySet<string>): Headers;
-/** Values known to be credentials, used only when producing public HTTP error diagnostics. */
-export declare function modelCredentialSensitiveValues(credential: ModelCredential): readonly string[];

package/dist/agent-core/model/runtime-credential.js

@@ -1,72 +0,0 @@
-import { MarAgentError } from '../error.js';
-import { SecretValue } from './configuration.js';
-export async function acquireModelCredential(configuration, reason, missingCredentialMessage, signal) {
-    signal?.throwIfAborted();
-    if (configuration.credentialProvider !== undefined) {
-        if (configuration.apiKey !== undefined)
-            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Model credential sources are ambiguous.');
-        const credential = await waitForModelCredential(configuration.credentialProvider, reason, signal);
-        signal?.throwIfAborted();
-        if (!Number.isSafeInteger(credential.revision) ||
-            credential.revision < 0 ||
-            !Number.isFinite(credential.expiresAt) ||
-            !(credential.bearer instanceof SecretValue) ||
-            credential.headers === null ||
-            typeof credential.headers !== 'object' ||
-            Array.isArray(credential.headers) ||
-            (credential.socks5Url !== undefined && !(credential.socks5Url instanceof SecretValue)))
-            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Dynamic model credential is invalid.');
-        return credential;
-    }
-    if (configuration.apiKey === undefined)
-        throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', missingCredentialMessage);
-    return {
-        revision: 0,
-        expiresAt: Number.MAX_SAFE_INTEGER,
-        bearer: configuration.apiKey,
-        headers: {}
-    };
-}
-async function waitForModelCredential(provider, reason, signal) {
-    if (signal === undefined)
-        return provider.acquire(reason);
-    let abort = () => { };
-    try {
-        return await new Promise((resolve, reject) => {
-            // Cancel only this request's wait; the shared provider remains caller-owned.
-            abort = () => reject(signal.reason);
-            signal.addEventListener('abort', abort, { once: true });
-            if (signal.aborted) {
-                abort();
-                return;
-            }
-            provider.acquire(reason).then(resolve, reject);
-        });
-    }
-    finally {
-        signal.removeEventListener('abort', abort);
-    }
-}
-export function appendModelCredentialHeaders(headers, credential, reservedHeaders) {
-    for (const [name, value] of Object.entries(credential.headers)) {
-        if (reservedHeaders.has(name.toLowerCase()))
-            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Dynamic model credential contains a reserved header.');
-        headers.set(name, value instanceof SecretValue ? value.reveal() : value);
-    }
-    return headers;
-}
-/** Values known to be credentials, used only when producing public HTTP error diagnostics. */
-export function modelCredentialSensitiveValues(credential) {
-    const values = [
-        credential.bearer.reveal(),
-        ...Object.values(credential.headers)
-            .filter((value) => value instanceof SecretValue)
-            .map((value) => value.reveal())
-    ];
-    if (credential.socks5Url !== undefined) {
-        const proxy = credential.socks5Url.reveal();
-        const url = new URL(proxy);
-        values.push(proxy, decodeURIComponent(url.username), decodeURIComponent(url.password));
-    }
-    return values;
-}

package/dist/agent-core/model/sse.js

@@ -1,281 +0,0 @@
-import { MarAgentError } from '../error.js';
-import { isRetryableModelHttpStatus } from './http.js';
-const DEFAULT_MODEL_STREAM_IDLE_TIMEOUT_MS = 300_000;
-const streamEventObservedAt = new WeakMap();
-export function observeModelStreamEvent(value, observedAt) {
-    if (typeof value === 'object' && value !== null && observedAt !== undefined)
-        streamEventObservedAt.set(value, observedAt);
-    return value;
-}
-export function modelStreamEventObservedAt(value) {
-    return typeof value === 'object' && value !== null ? streamEventObservedAt.get(value) : undefined;
-}
-export async function* parseSse(response, signal, maxBytes = 16 * 1024 * 1024, idleTimeoutMs = DEFAULT_MODEL_STREAM_IDLE_TIMEOUT_MS, sensitiveValues = []) {
-    if (!response.ok) {
-        const redact = responseRedactor(sensitiveValues);
-        const body = redact(await readResponseText(response, signal, maxBytes, idleTimeoutMs));
-        const header = (name, limit) => {
-            const value = response.headers.get(name);
-            return value === null ? null : redact(value).slice(0, limit);
-        };
-        const upstream = upstreamError(body);
-        const code = upstream?.code ??
-            (response.status === 401 || response.status === 403
-                ? 'MAR_AGENT_MODEL_AUTH_FAILED'
-                : response.status === 429
-                    ? 'MAR_AGENT_MODEL_RATE_LIMITED'
-                    : response.status === 408 || response.status === 504
-                        ? 'MAR_AGENT_MODEL_TIMEOUT'
-                        : 'MAR_AGENT_MODEL_PROTOCOL_ERROR');
-        throw new MarAgentError(code, upstream?.message ?? `Model endpoint returned HTTP ${response.status}.`, {
-            details: {
-                status: response.status,
-                body: body.slice(0, 4096),
-                bodyTruncated: body.length > 4096,
-                contentType: header('content-type', 256),
-                requestId: header('x-request-id', 256) ?? header('request-id', 256),
-                retryAfter: header('retry-after', 128)
-            },
-            retryable: isRetryableModelHttpStatus(response.status)
-        });
-    }
-    if (response.body === null)
-        throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Model response has no body.');
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-    let total = 0;
-    let streamCompleted = false;
-    const receiverAbort = new AbortController();
-    const receiverSignal = AbortSignal.any([signal, receiverAbort.signal]);
-    const chunks = [];
-    let nextChunk = 0;
-    let receivedAll = false;
-    let receiverFailure;
-    let wake;
-    const notify = () => {
-        wake?.();
-        wake = undefined;
-    };
-    // Keep transport receipt independent of async SDK publication and persistence.
-    // The cumulative response byte limit also bounds the pending raw chunk queue.
-    const receive = (async () => {
-        try {
-            while (true) {
-                const { value, done } = await readStreamChunk(reader, receiverSignal, idleTimeoutMs);
-                const observedAt = performance.now();
-                if (done) {
-                    streamCompleted = true;
-                    break;
-                }
-                total += value.byteLength;
-                enforceResponseSize(total, maxBytes);
-                if (value.byteLength === 0)
-                    continue;
-                chunks.push({ value, observedAt });
-                notify();
-            }
-        }
-        catch (error) {
-            receiverFailure = { error };
-            await reader.cancel(error).catch(() => undefined);
-        }
-        finally {
-            receivedAll = true;
-            notify();
-        }
-    })();
-    try {
-        while (true) {
-            signal.throwIfAborted();
-            const chunk = chunks[nextChunk];
-            if (chunk === undefined) {
-                if (receivedAll) {
-                    if (receiverFailure !== undefined)
-                        throw receiverFailure.error;
-                    break;
-                }
-                await new Promise((resolve) => {
-                    wake = resolve;
-                });
-                continue;
-            }
-            chunks[nextChunk++] = undefined;
-            if (nextChunk >= 1_024 && nextChunk * 2 >= chunks.length) {
-                chunks.splice(0, nextChunk);
-                nextChunk = 0;
-            }
-            const { value, observedAt } = chunk;
-            const text = decoder.decode(value, { stream: true });
-            // Normalize CRLF across transport chunks as well as within each chunk.
-            if (buffer.endsWith('\r') && text.startsWith('\n'))
-                buffer = buffer.slice(0, -1);
-            buffer += text.replaceAll('\r\n', '\n');
-            let boundary;
-            while ((boundary = buffer.indexOf('\n\n')) >= 0) {
-                const frame = buffer.slice(0, boundary);
-                buffer = buffer.slice(boundary + 2);
-                const data = frame
-                    .split('\n')
-                    .filter((line) => line.startsWith('data:'))
-                    .map((line) => line.slice(5).trimStart())
-                    .join('\n');
-                if (data.length === 0 || data === '[DONE]')
-                    continue;
-                try {
-                    yield observeModelStreamEvent(JSON.parse(data), observedAt);
-                }
-                catch (cause) {
-                    throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Model SSE contained invalid JSON.', { cause });
-                }
-            }
-        }
-        buffer += decoder.decode();
-        if (buffer.trim().length > 0)
-            throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Model SSE ended with an incomplete frame.');
-    }
-    finally {
-        receiverAbort.abort();
-        await receive;
-        await closeReader(reader, streamCompleted);
-    }
-}
-async function readResponseText(response, signal, maxBytes, idleTimeoutMs) {
-    if (response.body === null)
-        return '';
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let body = '';
-    let total = 0;
-    let streamCompleted = false;
-    try {
-        while (true) {
-            const { value, done } = await readStreamChunk(reader, signal, idleTimeoutMs);
-            if (done) {
-                streamCompleted = true;
-                break;
-            }
-            total += value.byteLength;
-            enforceResponseSize(total, maxBytes);
-            body += decoder.decode(value, { stream: true });
-        }
-        return body + decoder.decode();
-    }
-    finally {
-        await closeReader(reader, streamCompleted);
-    }
-}
-function enforceResponseSize(total, maxBytes) {
-    if (total > maxBytes)
-        throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Model response exceeded the size limit.');
-}
-async function closeReader(reader, streamCompleted) {
-    if (!streamCompleted)
-        await reader.cancel().catch(() => undefined);
-    try {
-        reader.releaseLock();
-    }
-    catch {
-        // Preserve the original read failure if cancellation could not settle the reader.
-    }
-}
-async function readStreamChunk(reader, signal, idleTimeoutMs) {
-    if (signal.aborted) {
-        void reader.cancel(signal.reason).catch(() => undefined);
-        throw signal.reason;
-    }
-    const timeoutError = new MarAgentError('MAR_AGENT_MODEL_TIMEOUT', 'Model stream was idle for too long.', {
-        details: { reason: 'MODEL_STREAM_IDLE_TIMEOUT' },
-        retryable: true
-    });
-    return await new Promise((resolve, reject) => {
-        let settled = false;
-        const cleanup = () => {
-            clearTimeout(timeout);
-            signal.removeEventListener('abort', abortFromCaller);
-        };
-        const resolveOnce = (result) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            resolve(result);
-        };
-        const rejectOnce = (reason) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            reject(reason);
-        };
-        const interrupt = (reason) => {
-            void reader.cancel(reason).catch(() => undefined);
-            rejectOnce(reason);
-        };
-        const abortFromCaller = () => interrupt(signal.reason);
-        signal.addEventListener('abort', abortFromCaller, { once: true });
-        const timeout = setTimeout(() => interrupt(timeoutError), Math.max(1, idleTimeoutMs));
-        reader.read().then(resolveOnce, (error) => {
-            rejectOnce(signal.aborted ? (signal.reason ?? error) : error);
-        });
-    });
-}
-function responseRedactor(sensitiveValues) {
-    const secrets = [
-        ...new Set(sensitiveValues.flatMap((value) => value ? [value, JSON.stringify(value).slice(1, -1), encodeURIComponent(value)] : []))
-    ].sort((left, right) => right.length - left.length);
-    return (value) => secrets.reduce((text, secret) => text.replaceAll(secret, '[REDACTED]'), value);
-}
-function upstreamError(body) {
-    let parsed;
-    try {
-        parsed = JSON.parse(body);
-    }
-    catch {
-        return undefined;
-    }
-    const root = record(parsed);
-    if (typeof root.error === 'string') {
-        const message = bounded(root.error, 1_000);
-        return message === undefined ? undefined : { message };
-    }
-    const error = record(root.error);
-    // K3-compatible gateways can put the error discriminator in `type` and omit `code`.
-    const code = bounded(text(error.code) ?? text(error.type), 80);
-    const message = bounded(text(error.message), 1_000);
-    return message === undefined ? undefined : { ...(code === undefined ? {} : { code }), message };
-}
-const RETRYABLE_UPSTREAM_OVERLOAD_CODES = new Set([
-    'rate_limit_error',
-    'overloaded_error',
-    'api_overloaded',
-    'server_is_overloaded',
-    'system_cpu_overloaded',
-    'resource_exhausted',
-    'temporarily_unavailable',
-    'service_unavailable'
-]);
-// Closed set of transient upstream capacity/overload error codes; never grows into a
-// vendor-specific or free-text error classification table.
-export function isRetryableUpstreamOverloadCode(code) {
-    return code !== undefined && RETRYABLE_UPSTREAM_OVERLOAD_CODES.has(code.toLowerCase());
-}
-function bounded(value, maximum) {
-    if (value === undefined)
-        return undefined;
-    const normalized = value.trim();
-    if (normalized.length === 0)
-        return undefined;
-    return [...normalized].slice(0, maximum).join('');
-}
-export function record(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value)
-        ? value
-        : {};
-}
-export function text(value) {
-    return typeof value === 'string' ? value : undefined;
-}
-export function number(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
-}

package/dist/agent-core/model/text-blocks.js

@@ -1,40 +0,0 @@
-import { MarAgentError } from '../error.js';
-/** Preserve explicit blocks only while their complete texts still match the actual prefix. */
-export function resolveModelTextBlocks(text, blocks) {
-    if (typeof text !== 'string' || !Array.isArray(blocks))
-        throw invalid();
-    const copied = blocks.map((block) => {
-        if (!block ||
-            typeof block !== 'object' ||
-            typeof block.text !== 'string' ||
-            (block.cache !== undefined && block.cache !== true))
-            throw invalid();
-        return { text: block.text, ...(block.cache === true ? { cache: true } : {}) };
-    });
-    let offset = 0;
-    const result = [];
-    for (const block of copied) {
-        if (!text.startsWith(block.text, offset))
-            break;
-        result.push(block);
-        offset += block.text.length;
-    }
-    if (offset < text.length)
-        result.push({ text: text.slice(offset) });
-    return result;
-}
-export function modelTextInput(value) {
-    if (typeof value === 'string')
-        return { text: value };
-    if (!Array.isArray(value))
-        throw invalid();
-    for (const block of value) {
-        if (!block || typeof block !== 'object' || typeof block.text !== 'string')
-            throw invalid();
-    }
-    const text = value.map((block) => block.text).join('');
-    return { text, blocks: resolveModelTextBlocks(text, value) };
-}
-function invalid() {
-    return new MarAgentError('MAR_AGENT_MODEL_TEXT_BLOCK_INVALID', 'Model text blocks are invalid.');
-}

package/dist/agent-core/model/tool-declarations.d.ts

@@ -1,4 +0,0 @@
-import type { MarAgentModelConfiguration } from './configuration.js';
-import type { ClientToolDefinition } from './contracts.js';
-/** Native Responses discovery carries deferred definitions in history, not the top-level catalog. */
-export declare function projectModelRequestTools(model: Pick<MarAgentModelConfiguration, 'protocol'>, tools: readonly ClientToolDefinition[], residentNames: ReadonlySet<string>): readonly ClientToolDefinition[];

package/dist/agent-core/model/transport-test.d.ts

@@ -1,3 +0,0 @@
-import type { MarAgentModelConfiguration } from './configuration.js';
-/** Probe a configured protocol without exposing its adapter or wire events. */
-export declare function testMarAgentModelTransport(configuration: MarAgentModelConfiguration, signal: AbortSignal): Promise<boolean>;

package/dist/agent-core/model/transport-test.js

@@ -1,23 +0,0 @@
-import { AnthropicMessagesAdapter } from './anthropic-messages.js';
-import { OpenAiResponsesAdapter } from './openai-responses.js';
-/** Probe a configured protocol without exposing its adapter or wire events. */
-export async function testMarAgentModelTransport(configuration, signal) {
-    const adapter = configuration.protocol === 'OPENAI_RESPONSES'
-        ? new OpenAiResponsesAdapter(configuration)
-        : new AnthropicMessagesAdapter(configuration);
-    try {
-        let completed = false;
-        for await (const event of adapter.start({
-            system: 'You are performing a model transport connectivity test.',
-            messages: [{ role: 'user', content: 'Reply with OK.' }],
-            tools: [],
-            allowTools: false
-        }, signal))
-            if (event.type === 'completed')
-                completed = true;
-        return completed;
-    }
-    finally {
-        await adapter.close?.();
-    }
-}

package/dist/agent-core/model/usage-observer.d.ts

@@ -1,31 +0,0 @@
-import type { MarAgentModelConfiguration } from './configuration.js';
-import type { ModelEvent, ModelRequest } from './contracts.js';
-/** Safe request facts, independent of conversation events and provider payloads. */
-export interface ModelRequestUsage {
-    readonly recordId: string;
-    readonly requestId: string;
-    readonly revision: number;
-    readonly modelConfigurationId: string;
-    readonly modelName: string;
-    readonly provider: string;
-    readonly requestedModel: string;
-    readonly actualModel?: string;
-    readonly responseId?: string;
-    readonly startedAt: number;
-    readonly endedAt?: number;
-    readonly state: 'running' | 'succeeded' | 'failed' | 'cancelled' | 'interrupted';
-    readonly inputTokens?: string;
-    readonly outputTokens?: string;
-    readonly cacheReadTokens?: string;
-    readonly cacheWriteTokens?: string;
-    readonly reasoningTokens?: string;
-}
-export interface ModelUsageObservation extends ModelRequestUsage {
-    readonly sessionId: string;
-    readonly executionId?: string;
-    readonly purpose: 'conversation' | 'compact' | 'title' | 'other';
-    readonly agentRole: 'root' | 'subagent';
-}
-export type ModelUsageObserver = (usage: ModelUsageObservation) => Promise<void> | void;
-/** Observe before retry prelude buffering so failed attempts retain reported usage. */
-export declare function observeModelRequestUsage(start: () => AsyncIterable<ModelEvent>, request: ModelRequest, configuration: MarAgentModelConfiguration, signal: AbortSignal, now?: () => number): AsyncIterable<ModelEvent>;

package/dist/agent-core/prompts/index.d.ts

@@ -1,20 +0,0 @@
-import type { ExecutionMode } from '../runtime/contracts.js';
-import { type CorePromptPart } from '../extensions/prompt-composition.js';
-export declare const MAR_AGENT_PROMPT_VERSION = "1.67";
-interface SystemPromptInput {
-    mode: ExecutionMode;
-    platform: string;
-    architecture?: string;
-    shell?: {
-        readonly name: string;
-        readonly path: string;
-    };
-    guaranteedCommands?: Readonly<Record<string, string>>;
-    workspace: string;
-    tools: readonly string[];
-    directTools?: readonly string[];
-    extension?: string | undefined;
-}
-export declare function buildSystemPrompt(input: SystemPromptInput): string;
-export declare function buildSystemPromptSections(input: SystemPromptInput): readonly CorePromptPart[];
-export {};