@myagentroam/agent 0.11.33 → 0.11.35

package/dist/agent-core/model/anthropic-thinking.js

@@ -1,33 +0,0 @@
-import { MarAgentError } from '../error.js';
-export const ANTHROPIC_THINKING_LIMITS = {
-    blockBytes: 512 * 1024,
-    contextBytes: 8 * 1024 * 1024
-};
-/** Whitelist opaque protocol state without interpreting or rewriting signed fields. */
-export function anthropicThinkingBlock(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const block = value;
-    const keys = Object.keys(block);
-    let result;
-    if (block.type === 'thinking' &&
-        typeof block.thinking === 'string' &&
-        typeof block.signature === 'string' &&
-        block.signature.length > 0 &&
-        keys.every((key) => ['type', 'thinking', 'signature'].includes(key)))
-        result = { type: 'thinking', thinking: block.thinking, signature: block.signature };
-    else if (block.type === 'redacted_thinking' &&
-        typeof block.data === 'string' &&
-        block.data.length > 0 &&
-        keys.every((key) => ['type', 'data'].includes(key)))
-        result = { type: 'redacted_thinking', data: block.data };
-    else
-        return undefined;
-    return Buffer.byteLength(JSON.stringify(result)) <= ANTHROPIC_THINKING_LIMITS.blockBytes
-        ? result
-        : undefined;
-}
-export function assertAnthropicThinkingBudget(bytes) {
-    if (bytes > ANTHROPIC_THINKING_LIMITS.contextBytes)
-        throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'Anthropic native thinking context exceeds its bounded context limit.');
-}

package/dist/agent-core/model/catalog-file.d.ts

@@ -1,80 +0,0 @@
-import { type MarAgentModelConfiguration, type ModelCatalog } from './configuration.js';
-export type CliModelCredentialSource = 'CODEX_AUTH_FILE';
-export interface CliModelConfiguration extends MarAgentModelConfiguration {
-    credentialSource?: CliModelCredentialSource;
-}
-export interface CliModelCatalog extends Omit<ModelCatalog, 'models'> {
-    models: readonly CliModelConfiguration[];
-}
-export declare const modelCatalogPath: (home: string) => string;
-export declare function readModelCatalog(home: string): Promise<CliModelCatalog>;
-export declare function writeModelCatalog(home: string, catalog: CliModelCatalog): Promise<void>;
-export declare function serializeModel(model: CliModelConfiguration): {
-    apiKey: string;
-    conversationModel?: boolean;
-    useResourceUrl?: boolean;
-    responsesConfigurationUpdates?: boolean;
-    codexCredential?: boolean;
-    responsesTransport?: import("./configuration.js").ResponsesTransport;
-    responsesPreviousResponseId?: boolean;
-    id: string;
-    name: string;
-    protocol: "OPENAI_RESPONSES" | "ANTHROPIC_MESSAGES";
-    baseUrl: string;
-    modelId: string;
-    contextWindowTokens: number;
-    maxOutputTokens: number;
-    inputCapabilities: ("TEXT" | "IMAGE")[];
-    outputCapabilities: ["TEXT"];
-    reasoningEfforts: ("low" | "medium" | "high" | "xhigh" | "max" | "ultra")[];
-    defaultReasoningEffort?: "low" | "medium" | "high" | "xhigh" | "max" | "ultra" | undefined;
-    titleGeneration: boolean;
-    codeMode: boolean;
-    fastMode?: boolean | undefined;
-    serviceTier?: "default" | "auto" | "flex" | "priority" | "fast" | "ultrafast" | undefined;
-    hostedWebSearch: boolean;
-    responsesToolNamespace?: string | undefined;
-    responsesOptionalParameters?: {
-        reasoningEffort: boolean;
-        reasoningSummary: boolean;
-        textVerbosity: boolean;
-        promptCacheKey: boolean;
-        nativeTools?: boolean | undefined;
-    } | undefined;
-    enabled: boolean;
-} | {
-    credential: {
-        type: "CODEX_AUTH_FILE";
-    };
-    conversationModel?: boolean;
-    useResourceUrl?: boolean;
-    responsesConfigurationUpdates?: boolean;
-    codexCredential?: boolean;
-    responsesTransport?: import("./configuration.js").ResponsesTransport;
-    responsesPreviousResponseId?: boolean;
-    id: string;
-    name: string;
-    protocol: "OPENAI_RESPONSES" | "ANTHROPIC_MESSAGES";
-    baseUrl: string;
-    modelId: string;
-    contextWindowTokens: number;
-    maxOutputTokens: number;
-    inputCapabilities: ("TEXT" | "IMAGE")[];
-    outputCapabilities: ["TEXT"];
-    reasoningEfforts: ("low" | "medium" | "high" | "xhigh" | "max" | "ultra")[];
-    defaultReasoningEffort?: "low" | "medium" | "high" | "xhigh" | "max" | "ultra" | undefined;
-    titleGeneration: boolean;
-    codeMode: boolean;
-    fastMode?: boolean | undefined;
-    serviceTier?: "default" | "auto" | "flex" | "priority" | "fast" | "ultrafast" | undefined;
-    hostedWebSearch: boolean;
-    responsesToolNamespace?: string | undefined;
-    responsesOptionalParameters?: {
-        reasoningEffort: boolean;
-        reasoningSummary: boolean;
-        textVerbosity: boolean;
-        promptCacheKey: boolean;
-        nativeTools?: boolean | undefined;
-    } | undefined;
-    enabled: boolean;
-};

package/dist/agent-core/model/catalog-file.js

@@ -1,103 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { MarAgentError } from '../error.js';
-import { parseModelCatalog } from './configuration.js';
-export const modelCatalogPath = (home) => join(home, '.mar', 'agent', 'models.json');
-export async function readModelCatalog(home) {
-    try {
-        return parseCliModelCatalog(JSON.parse(await readFile(modelCatalogPath(home), 'utf8')), {
-            allowLoopbackHttp: true
-        });
-    }
-    catch (cause) {
-        if (cause instanceof MarAgentError)
-            throw cause;
-        if (cause.code === 'ENOENT')
-            return { version: 1, models: [] };
-        throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Model catalog cannot be read.', {
-            cause
-        });
-    }
-}
-export async function writeModelCatalog(home, catalog) {
-    const path = modelCatalogPath(home);
-    await mkdir(join(home, '.mar', 'agent'), { recursive: true });
-    const raw = {
-        version: 1,
-        ...(catalog.defaultModelId ? { defaultModelId: catalog.defaultModelId } : {}),
-        models: catalog.models.map(serializeModel)
-    };
-    parseCliModelCatalog(raw, { allowLoopbackHttp: true });
-    const temporary = `${path}.${randomUUID()}.tmp`;
-    await writeFile(temporary, `${JSON.stringify(raw, null, 2)}\n`, { mode: 0o600 });
-    await rename(temporary, path);
-}
-export function serializeModel(model) {
-    const { apiKey, credentialProvider, credentialSource, ...configuration } = model;
-    if (apiKey !== undefined) {
-        if (credentialProvider !== undefined || credentialSource !== undefined)
-            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Model credential sources are ambiguous.');
-        return { ...configuration, apiKey: apiKey.reveal() };
-    }
-    if (credentialSource !== undefined)
-        return {
-            ...configuration,
-            credential: { type: credentialSource }
-        };
-    throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Dynamic model credentials cannot be persisted without an external credential marker.');
-}
-function parseCliModelCatalog(input, options = {}) {
-    if (!isRecord(input) || !Array.isArray(input.models))
-        return parseModelCatalog(input, options);
-    const externalCredentialModels = new Set();
-    const normalizedModels = input.models.map((model, index) => {
-        if (isRecord(model) && Object.hasOwn(model, 'highDensityCompaction')) {
-            if (typeof model.highDensityCompaction !== 'boolean')
-                throw invalidCatalog();
-            const { highDensityCompaction: _compaction, ...configuration } = model;
-            void _compaction;
-            model = configuration;
-        }
-        if (isRecord(model) && Object.hasOwn(model, 'responsesEncoding')) {
-            if (model.protocol !== 'OPENAI_RESPONSES' ||
-                (model.responsesEncoding !== 'STANDARD' && model.responsesEncoding !== 'LITE'))
-                throw invalidCatalog();
-            const { responsesEncoding: _encoding, ...configuration } = model;
-            void _encoding;
-            model = configuration;
-        }
-        if (!isRecord(model) || !Object.hasOwn(model, 'credential'))
-            return model;
-        const credential = model.credential;
-        if (!isRecord(credential) ||
-            credential.type !== 'CODEX_AUTH_FILE' ||
-            Object.keys(credential).length !== 1)
-            throw invalidCatalog();
-        if (Object.hasOwn(model, 'apiKey'))
-            throw invalidCatalog();
-        externalCredentialModels.add(index);
-        const { credential: _credential, ...configuration } = model;
-        void _credential;
-        return { ...configuration, apiKey: '__MAR_AGENT_EXTERNAL_CREDENTIAL__' };
-    });
-    const parsed = parseModelCatalog({ ...input, models: normalizedModels }, options);
-    return {
-        ...parsed,
-        models: parsed.models.map((model, index) => {
-            if (!externalCredentialModels.has(index))
-                return model;
-            if (model.protocol !== 'OPENAI_RESPONSES')
-                throw invalidCatalog();
-            const { apiKey: _apiKey, ...configuration } = model;
-            void _apiKey;
-            return { ...configuration, credentialSource: 'CODEX_AUTH_FILE' };
-        })
-    };
-}
-function isRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-function invalidCatalog() {
-    return new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Model catalog is invalid.');
-}

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

@@ -1,127 +0,0 @@
-import { z } from 'zod';
-export declare class SecretValue {
-    #private;
-    constructor(value: string);
-    reveal(): string;
-    toJSON(): string;
-    toString(): string;
-}
-export type ModelCredentialAcquireReason = 'REQUEST' | 'UNAUTHORIZED' | 'RECONNECT';
-export interface ModelCredential {
-    readonly revision: number;
-    readonly expiresAt: number;
-    readonly bearer: SecretValue;
-    readonly headers: Readonly<Record<string, SecretValue | string>>;
-    readonly socks5Url?: SecretValue;
-}
-export interface ModelCredentialProvider {
-    acquire(reason: ModelCredentialAcquireReason): Promise<ModelCredential>;
-    invalidate(revision: number): void | Promise<void>;
-    close(): Promise<void>;
-}
-export type ResponsesTransport = {
-    readonly transport: 'HTTP';
-    readonly httpVersion: '1.1' | '2';
-} | {
-    readonly transport: 'WEBSOCKET';
-};
-export declare const marAgentReasoningEffortSchema: z.ZodEnum<{
-    low: "low";
-    medium: "medium";
-    high: "high";
-    xhigh: "xhigh";
-    max: "max";
-    ultra: "ultra";
-}>;
-export type MarAgentReasoningEffort = z.infer<typeof marAgentReasoningEffortSchema>;
-declare const rawModelSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    protocol: z.ZodEnum<{
-        OPENAI_RESPONSES: "OPENAI_RESPONSES";
-        ANTHROPIC_MESSAGES: "ANTHROPIC_MESSAGES";
-    }>;
-    baseUrl: z.ZodString;
-    apiKey: z.ZodString;
-    modelId: z.ZodString;
-    contextWindowTokens: z.ZodNumber;
-    maxOutputTokens: z.ZodNumber;
-    inputCapabilities: z.ZodArray<z.ZodEnum<{
-        TEXT: "TEXT";
-        IMAGE: "IMAGE";
-    }>>;
-    outputCapabilities: z.ZodTuple<[z.ZodLiteral<"TEXT">], null>;
-    reasoningEfforts: z.ZodArray<z.ZodEnum<{
-        low: "low";
-        medium: "medium";
-        high: "high";
-        xhigh: "xhigh";
-        max: "max";
-        ultra: "ultra";
-    }>>;
-    defaultReasoningEffort: z.ZodOptional<z.ZodEnum<{
-        low: "low";
-        medium: "medium";
-        high: "high";
-        xhigh: "xhigh";
-        max: "max";
-        ultra: "ultra";
-    }>>;
-    conversationModel: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    titleGeneration: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    codeMode: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    useResourceUrl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    fastMode: z.ZodOptional<z.ZodBoolean>;
-    serviceTier: z.ZodOptional<z.ZodEnum<{
-        default: "default";
-        auto: "auto";
-        flex: "flex";
-        priority: "priority";
-        fast: "fast";
-        ultrafast: "ultrafast";
-    }>>;
-    hostedWebSearch: z.ZodBoolean;
-    responsesTransport: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        transport: z.ZodLiteral<"HTTP">;
-        httpVersion: z.ZodEnum<{
-            1.1: "1.1";
-            2: "2";
-        }>;
-    }, z.core.$strict>, z.ZodObject<{
-        transport: z.ZodLiteral<"WEBSOCKET">;
-    }, z.core.$strict>], "transport">>;
-    responsesToolNamespace: z.ZodOptional<z.ZodString>;
-    responsesPreviousResponseId: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    responsesOptionalParameters: z.ZodOptional<z.ZodObject<{
-        reasoningEffort: z.ZodBoolean;
-        reasoningSummary: z.ZodBoolean;
-        textVerbosity: z.ZodBoolean;
-        promptCacheKey: z.ZodBoolean;
-        nativeTools: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>>;
-    enabled: z.ZodBoolean;
-}, z.core.$strict>;
-export interface MarAgentModelConfiguration extends Omit<z.infer<typeof rawModelSchema>, 'apiKey' | 'responsesPreviousResponseId' | 'responsesTransport' | 'conversationModel' | 'useResourceUrl'> {
-    conversationModel?: boolean;
-    useResourceUrl?: boolean;
-    apiKey?: SecretValue;
-    credentialProvider?: ModelCredentialProvider;
-    /** Whether this Responses endpoint accepts native configuration_update input items. */
-    responsesConfigurationUpdates?: boolean;
-    /** @deprecated Use responsesConfigurationUpdates. */
-    codexCredential?: boolean;
-    responsesTransport?: ResponsesTransport;
-    responsesPreviousResponseId?: boolean;
-}
-export declare function supportsResponsesConfigurationUpdates(model: Pick<MarAgentModelConfiguration, 'responsesConfigurationUpdates' | 'codexCredential'>): boolean;
-export declare function usesResponsesConfigurationUpdates(model: Pick<MarAgentModelConfiguration, 'protocol' | 'responsesConfigurationUpdates' | 'codexCredential'>): boolean;
-export interface ModelCatalog {
-    version: 1;
-    defaultModelId?: string;
-    models: readonly MarAgentModelConfiguration[];
-}
-export declare function resolveModelDefaultReasoningEffort(model: Pick<MarAgentModelConfiguration, 'defaultReasoningEffort' | 'reasoningEfforts'>): MarAgentReasoningEffort;
-export declare function parseModelCatalog(input: unknown, options?: {
-    allowLoopbackHttp?: boolean;
-}): ModelCatalog;
-export {};

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

@@ -1,168 +0,0 @@
-import { z } from 'zod';
-import { MarAgentError } from '../error.js';
-export class SecretValue {
-    #value;
-    constructor(value) {
-        if (value.length === 0)
-            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'API key is required.');
-        this.#value = value;
-    }
-    reveal() {
-        return this.#value;
-    }
-    toJSON() {
-        return '[REDACTED]';
-    }
-    toString() {
-        return '[REDACTED]';
-    }
-}
-const rawResponsesTransportSchema = z.discriminatedUnion('transport', [
-    z.object({ transport: z.literal('HTTP'), httpVersion: z.enum(['1.1', '2']) }).strict(),
-    z.object({ transport: z.literal('WEBSOCKET') }).strict()
-]);
-export const marAgentReasoningEffortSchema = z.enum([
-    'low',
-    'medium',
-    'high',
-    'xhigh',
-    'max',
-    'ultra'
-]);
-const rawModelSchema = z
-    .object({
-    id: z
-        .string()
-        .min(1)
-        .max(128)
-        .regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/),
-    name: z.string().trim().min(1).max(128),
-    protocol: z.enum(['OPENAI_RESPONSES', 'ANTHROPIC_MESSAGES']),
-    baseUrl: z.string().url(),
-    apiKey: z.string().min(1).max(16_384),
-    modelId: z.string().min(1).max(256),
-    contextWindowTokens: z.number().int().positive(),
-    maxOutputTokens: z.number().int().positive(),
-    inputCapabilities: z.array(z.enum(['TEXT', 'IMAGE'])).min(1),
-    outputCapabilities: z.tuple([z.literal('TEXT')]),
-    reasoningEfforts: z.array(marAgentReasoningEffortSchema),
-    defaultReasoningEffort: marAgentReasoningEffortSchema.optional(),
-    conversationModel: z.boolean().optional().default(true),
-    titleGeneration: z.boolean().optional().default(false),
-    codeMode: z.boolean().optional().default(false),
-    useResourceUrl: z.boolean().optional().default(false),
-    fastMode: z.boolean().optional(),
-    serviceTier: z.enum(['auto', 'default', 'flex', 'priority', 'fast', 'ultrafast']).optional(),
-    hostedWebSearch: z.boolean(),
-    responsesTransport: rawResponsesTransportSchema.optional(),
-    responsesToolNamespace: z
-        .string()
-        .regex(/^[a-zA-Z][a-zA-Z0-9_]{0,63}$/u)
-        .optional(),
-    responsesPreviousResponseId: z.boolean().optional().default(false),
-    responsesOptionalParameters: z
-        .object({
-        reasoningEffort: z.boolean(),
-        reasoningSummary: z.boolean(),
-        textVerbosity: z.boolean(),
-        promptCacheKey: z.boolean(),
-        nativeTools: z.boolean().optional()
-    })
-        .strict()
-        .optional(),
-    enabled: z.boolean()
-})
-    .strict()
-    .superRefine((value, context) => {
-    if (!value.inputCapabilities.includes('TEXT'))
-        context.addIssue({ code: 'custom', message: 'TEXT input capability is required.' });
-    if (value.maxOutputTokens >= value.contextWindowTokens)
-        context.addIssue({
-            code: 'custom',
-            message: 'Output limit must be smaller than context window.'
-        });
-    if (value.defaultReasoningEffort !== undefined &&
-        value.reasoningEfforts.length > 0 &&
-        !value.reasoningEfforts.includes(value.defaultReasoningEffort))
-        context.addIssue({
-            code: 'custom',
-            path: ['defaultReasoningEffort'],
-            message: 'Default reasoning effort must be included in the exposed choices.'
-        });
-    if (value.protocol === 'ANTHROPIC_MESSAGES' && value.hostedWebSearch)
-        context.addIssue({
-            code: 'custom',
-            message: 'Hosted Web is not declared by the Anthropic Messages compatibility adapter.'
-        });
-    if (value.protocol !== 'OPENAI_RESPONSES' && value.responsesPreviousResponseId)
-        context.addIssue({ code: 'custom', message: 'Responses continuation requires Responses.' });
-    if (value.protocol !== 'OPENAI_RESPONSES' && value.responsesTransport !== undefined)
-        context.addIssue({ code: 'custom', message: 'Responses transport requires Responses.' });
-    if (value.responsesToolNamespace !== undefined && value.protocol !== 'OPENAI_RESPONSES')
-        context.addIssue({
-            code: 'custom',
-            path: ['responsesToolNamespace'],
-            message: 'Tool namespaces require Standard OpenAI Responses.'
-        });
-    if (value.protocol !== 'OPENAI_RESPONSES' && value.fastMode === true)
-        context.addIssue({ code: 'custom', message: 'Fast mode requires Responses.' });
-    if (value.protocol !== 'OPENAI_RESPONSES' && value.serviceTier !== undefined)
-        context.addIssue({ code: 'custom', message: 'Service tier requires Responses.' });
-});
-export function supportsResponsesConfigurationUpdates(model) {
-    return model.responsesConfigurationUpdates ?? model.codexCredential === true;
-}
-export function usesResponsesConfigurationUpdates(model) {
-    return model.protocol === 'OPENAI_RESPONSES' && supportsResponsesConfigurationUpdates(model);
-}
-export function resolveModelDefaultReasoningEffort(model) {
-    const configured = marAgentReasoningEffortSchema.safeParse(model.defaultReasoningEffort);
-    if (configured.success &&
-        (model.reasoningEfforts.length === 0 || model.reasoningEfforts.includes(configured.data)))
-        return configured.data;
-    return model.reasoningEfforts.includes('medium')
-        ? 'medium'
-        : (model.reasoningEfforts[0] ?? 'medium');
-}
-export function parseModelCatalog(input, options = {}) {
-    const catalogSchema = z.object({
-        version: z.literal(1),
-        defaultModelId: z.string().optional(),
-        models: z.array(rawModelSchema)
-    });
-    const parsed = catalogSchema.safeParse(input);
-    if (!parsed.success)
-        throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Model catalog is invalid.', {
-            details: { issues: parsed.error.issues.map((issue) => issue.message) }
-        });
-    const ids = new Set();
-    const names = new Set();
-    for (const model of parsed.data.models) {
-        const url = new URL(model.baseUrl);
-        const loopback = url.hostname === '127.0.0.1' || url.hostname === 'localhost' || url.hostname === '::1';
-        if (url.username ||
-            url.password ||
-            url.search ||
-            url.hash ||
-            (url.protocol !== 'https:' && !(options.allowLoopbackHttp && loopback)))
-            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Model base URL is not allowed.');
-        const normalizedName = model.name.normalize('NFKC').toLocaleLowerCase('en-US');
-        if (ids.has(model.id) || names.has(normalizedName))
-            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Model identifiers and names must be unique.');
-        ids.add(model.id);
-        names.add(normalizedName);
-    }
-    if (parsed.data.defaultModelId !== undefined && !ids.has(parsed.data.defaultModelId))
-        throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Default model does not exist.');
-    return {
-        version: 1,
-        ...(parsed.data.defaultModelId === undefined
-            ? {}
-            : { defaultModelId: parsed.data.defaultModelId }),
-        models: parsed.data.models.map(({ apiKey, responsesTransport, ...model }) => ({
-            ...model,
-            apiKey: new SecretValue(apiKey),
-            ...(responsesTransport === undefined ? {} : { responsesTransport })
-        }))
-    };
-}