@myagentroam/agent 0.10.20 → 0.10.22

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

@@ -11,6 +11,7 @@ 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;
     responsesConfigurationUpdates?: boolean;
     codexCredential?: boolean;
     responsesTransport?: import("./configuration.js").ResponsesTransport;
@@ -44,6 +45,7 @@ export declare function serializeModel(model: CliModelConfiguration): {
     credential: {
         type: "CODEX_AUTH_FILE";
     };
+    conversationModel?: boolean;
     responsesConfigurationUpdates?: boolean;
     codexCredential?: boolean;
     responsesTransport?: import("./configuration.js").ResponsesTransport;

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

@@ -67,6 +67,7 @@ declare const rawModelSchema: z.ZodObject<{
         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>>;
     fastMode: z.ZodOptional<z.ZodBoolean>;
@@ -99,7 +100,8 @@ declare const rawModelSchema: z.ZodObject<{
     }, z.core.$strict>>;
     enabled: z.ZodBoolean;
 }, z.core.$strict>;
-export interface MarAgentModelConfiguration extends Omit<z.infer<typeof rawModelSchema>, 'apiKey' | 'responsesPreviousResponseId' | 'responsesTransport'> {
+export interface MarAgentModelConfiguration extends Omit<z.infer<typeof rawModelSchema>, 'apiKey' | 'responsesPreviousResponseId' | 'responsesTransport' | 'conversationModel'> {
+    conversationModel?: boolean;
     apiKey?: SecretValue;
     credentialProvider?: ModelCredentialProvider;
     /** Whether this Responses endpoint accepts native configuration_update input items. */

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

@@ -47,6 +47,7 @@ const rawModelSchema = z
     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),
     fastMode: z.boolean().optional(),

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

@@ -21,9 +21,12 @@ export function resolveAgentModels(configurations, requestedDefaultModelId) {
     const models = new Map(configuredModels.filter((model) => model.enabled).map((model) => [model.id, model]));
     if (models.size === 0)
         throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'At least one enabled model is required.');
-    const defaultModelId = requestedDefaultModelId ?? models.keys().next().value;
-    if (!models.has(defaultModelId))
-        throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Default model is unavailable.');
+    const defaultModelId = requestedDefaultModelId ??
+        [...models.values()].find((model) => model.conversationModel !== false)?.id;
+    if (!defaultModelId ||
+        !models.has(defaultModelId) ||
+        models.get(defaultModelId).conversationModel === false)
+        throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Default conversation model is unavailable.');
     return { models, defaultModelId, credentialProviders };
 }
 export function createModelTurnSession(adapter) {

package/dist/agent-core/sdk/session.js

@@ -190,6 +190,10 @@ export function createSessionOpener(services) {
             services.assertCanStart();
             if ([...active.keys()].some((key) => key.startsWith(`${sessionId}:`)))
                 throw new MarAgentError('MAR_AGENT_EXECUTION_ACTIVE', 'Session already has an active execution.');
+            const { models: executionModels, defaultModelId: executionDefaultModelId, generation: executionModelGeneration } = services.modelState();
+            if (mode !== 'compact' &&
+                executionModels.get(input.modelId ?? executionDefaultModelId)?.conversationModel === false)
+                throw new MarAgentError('MAR_AGENT_MODEL_DISABLED', 'The selected model is not a conversation model.');
             const executionId = randomUUID(), turnId = internal.turnId ?? randomUUID(), queue = new AsyncQueue(), controller = new AbortController();
             const abortSource = () => controller.abort(internal.signal?.reason);
             internal.signal?.addEventListener('abort', abortSource, { once: true });
@@ -199,7 +203,6 @@ export function createSessionOpener(services) {
                 ...currentEnvironment,
                 ...currentLocalTimeContext()
             };
-            const { models: executionModels, defaultModelId: executionDefaultModelId, generation: executionModelGeneration } = services.modelState();
             const executionSystemInstruction = settings.systemInstruction;
             promptDefaults = {
                 executionId,
@@ -610,7 +613,9 @@ export function createSessionOpener(services) {
                         throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Host tools cannot use the MCP namespace.');
                     const selectedModelForTools = executionModels.get(input.modelId ?? executionDefaultModelId);
                     const builtinTools = BUILTIN_TOOL_DEFINITIONS.map((tool) => tool.name === 'agent_start'
-                        ? agentStartToolDefinitionWithModels([...executionModels.values()].map((configuration) => ({
+                        ? agentStartToolDefinitionWithModels([...executionModels.values()]
+                            .filter((configuration) => configuration.conversationModel !== false)
+                            .map((configuration) => ({
                             id: configuration.id,
                             name: configuration.name,
                             reasoningEfforts: configuration.reasoningEfforts

package/dist/agent-core/subagent/session-controller.d.ts

@@ -7,6 +7,7 @@ import type { SubagentController, SubagentMessageOptions, SubagentOutputOptions,
 export interface SubagentModelOption {
     readonly id: string;
     readonly name: string;
+    readonly conversationModel?: boolean;
     readonly reasoningEfforts: readonly MarAgentReasoningEffort[];
     readonly defaultReasoningEffort: MarAgentReasoningEffort;
 }

package/dist/agent-core/subagent/session-controller.js

@@ -938,7 +938,7 @@ function validateTaskInput(input, native = false) {
 function resolveModel(execution, input) {
     const modelId = input.modelId ?? execution.modelId;
     const model = execution.models.get(modelId);
-    if (!model)
+    if (!model || model.conversationModel === false)
         throw new MarAgentError('MAR_AGENT_SUBAGENT_MODEL_UNAVAILABLE', 'Selected model is unavailable for subagents.');
     if (input.reasoningEffort !== undefined &&
         !model.reasoningEfforts.includes(input.reasoningEffort))

package/dist/cli/main.js

@@ -180,6 +180,7 @@ async function modelsCommand(home, arguments_, codexAuthFile) {
                 defaultReasoningEffort: existing?.defaultReasoningEffort
             })
             : parseReasoningEffort(defaultReasoningEffortOption, '--default-reasoning-effort'),
+        conversationModel: existing?.conversationModel ?? true,
         titleGeneration: existing?.titleGeneration ?? false,
         codeMode: booleanFlag(arguments_, '--code-mode', '--no-code-mode', existing?.codeMode ?? false),
         ...(credential === 'codex-auth-file' && fastMode ? { fastMode: true } : {}),
@@ -252,7 +253,7 @@ async function main() {
         throw new MarAgentError('MAR_AGENT_CLI_ARGUMENT_INVALID', 'The deprecated --access option only accepts full-access.');
     const format = takeOption(arguments_, '--format') ?? 'text';
     const command = arguments_[0];
-    const selectedModel = catalog.models.find((model) => model.id === modelId && model.enabled);
+    const selectedModel = catalog.models.find((model) => model.id === modelId && model.enabled && model.conversationModel !== false);
     if (selectedModel !== undefined)
         assertExternalCredentialAvailable(selectedModel, codexAuthFile);
     if (reasoningEffort && selectedModel && !selectedModel.reasoningEfforts.includes(reasoningEffort))
@@ -360,7 +361,8 @@ async function main() {
                             models: runtime.models,
                             currentModelId: modelId ??
                                 catalog.defaultModelId ??
-                                runtime.models.find((model) => model.enabled).id,
+                                runtime.models.find((model) => model.enabled && model.conversationModel !== false)
+                                    .id,
                             prompt: invocation.prompt,
                             signal: titleController.signal
                         }).catch(() => undefined);

package/dist/index.d.ts

@@ -11,7 +11,7 @@ export { testMarAgentModelTransport } from './agent-core/model/transport-test.js
 export type { AccessMode, ExecutionMode, ExecutionResult, MarAgentImageMetadata, RolloutBudgetOptions, RunInput, RunInputImage } from './agent-core/runtime/contracts.js';
 export type { MarAgentEvent } from './agent-core/runtime/events.js';
 export { createMarAgent } from './agent-core/sdk/agent.js';
-export { generateModelText, type GenerateModelTextInput } from './shared/model-text.js';
+export { generateModelText, type GenerateModelTextInput, type GenerateModelTextResult } from './shared/model-text.js';
 export type { CoreAgentExtensionContext, CoreSessionExtensionContext, CoreRuntimeExtension, CoreExtensionSnapshot, CoreExtensionSource, CoreExtensionDiagnostic, CoreDomainOperations, CoreDomainFacts, CoreHookRegistrar, CoreCapabilitySnapshot, CoreCommandSpec, CorePromptSection, CoreServiceDeclaration, CoreServiceDependency } from './agent-core/extensions/contracts.js';
 export type { CoreDisposer, CoreResourceRegistration, CoreResourceScope } from './agent-core/extensions/resources.js';
 export type { CoreHookOptions, CoreInterceptor } from './agent-core/extensions/hooks.js';

package/dist/shared/model-text.d.ts

@@ -1,19 +1,26 @@
 import { type MarAgentModelConfiguration, type MarAgentReasoningEffort } from '../agent-core/model/configuration.js';
 import type { ModelAttemptDiagnostic, ModelUsage } from '../agent-core/model/contracts.js';
 import type { CoreCompactMessage } from '../agent-core/extensions/compaction.js';
+import type { ClientToolDefinition, ToolCall } from '../agent-core/tools/contracts.js';
 export interface GenerateModelTextInput {
     readonly onModelUsage?: (usage: import('../agent-core/model/usage-observer.js').ModelRequestUsage) => Promise<void> | void;
     readonly onModelUsageFailure?: () => void;
     readonly model: MarAgentModelConfiguration;
     readonly system: string;
     readonly messages: readonly CoreCompactMessage[];
+    /** Declarative client tools only. Returned calls are never executed or continued here. */
+    readonly tools?: readonly ClientToolDefinition[];
+    readonly promptCacheKey?: string;
+    readonly cachePrefixMessages?: number;
     readonly reasoningEffort?: MarAgentReasoningEffort;
     readonly outputLimit?: number;
     readonly signal: AbortSignal;
     readonly onAttemptDiagnostic?: (diagnostic: ModelAttemptDiagnostic) => Promise<void> | void;
 }
-/** One tool-free request using the SDK transports. Credential providers remain caller-owned. */
-export declare function generateModelText(input: GenerateModelTextInput): Promise<{
-    text: string;
-    usage?: ModelUsage;
-} | undefined>;
+export interface GenerateModelTextResult {
+    readonly text: string;
+    readonly toolCalls?: readonly ToolCall[];
+    readonly usage?: ModelUsage;
+}
+/** One request using the SDK transports, without tool execution or a Session. */
+export declare function generateModelText(input: GenerateModelTextInput): Promise<GenerateModelTextResult | undefined>;

package/dist/shared/model-text.js

@@ -3,16 +3,20 @@ import { MarAgentError } from '../agent-core/error.js';
 import { AnthropicMessagesAdapter } from '../agent-core/model/anthropic-messages.js';
 import { OpenAiResponsesAdapter } from '../agent-core/model/openai-responses.js';
 import { resolveModelDefaultReasoningEffort } from '../agent-core/model/configuration.js';
-/** One tool-free request using the SDK transports. Credential providers remain caller-owned. */
+/** One request using the SDK transports, without tool execution or a Session. */
 export async function generateModelText(input) {
     input.signal.throwIfAborted();
     if (!input.model.enabled)
         return undefined;
+    const tools = input.tools ?? [];
+    // Standalone calls expose only the caller's declared client tools, never hosted search.
+    const model = { ...input.model, hostedWebSearch: false };
     const adapter = input.model.protocol === 'OPENAI_RESPONSES'
-        ? new OpenAiResponsesAdapter(input.model)
-        : new AnthropicMessagesAdapter(input.model);
+        ? new OpenAiResponsesAdapter(model)
+        : new AnthropicMessagesAdapter(model);
     let text = '';
     let completed = false;
+    const toolCalls = [];
     let usage;
     try {
         for await (const event of adapter.start({
@@ -23,11 +27,15 @@ export async function generateModelText(input) {
                 ? {}
                 : { onModelUsageFailure: input.onModelUsageFailure }),
             system: input.system,
+            ...(input.cachePrefixMessages === undefined
+                ? {}
+                : { cachePrefixMessages: input.cachePrefixMessages }),
             messages: input.messages,
-            tools: [],
-            allowTools: false,
-            toolChoice: 'none',
+            tools,
+            allowTools: tools.length > 0,
+            toolChoice: tools.length > 0 ? 'auto' : 'none',
             reasoningEffort: input.reasoningEffort ?? resolveModelDefaultReasoningEffort(input.model),
+            ...(input.promptCacheKey === undefined ? {} : { promptCacheKey: input.promptCacheKey }),
             ...(input.onAttemptDiagnostic ? { onAttemptDiagnostic: input.onAttemptDiagnostic } : {}),
             ...(input.outputLimit === undefined ? {} : { outputLimit: input.outputLimit })
         }, input.signal)) {
@@ -37,12 +45,22 @@ export async function generateModelText(input) {
             else if (event.type === 'usage')
                 usage = event.usage;
             else if (event.type === 'completed')
-                completed = event.reason === 'completed';
-            else if (event.type === 'client_tool.call')
-                throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Text generation returned a tool call while tools were disabled.');
+                completed =
+                    event.reason === 'completed' || (event.reason === 'tool_use' && toolCalls.length > 0);
+            else if (event.type === 'client_tool.call') {
+                if (!tools.some((tool) => tool.name === event.name) || event.argumentError !== undefined)
+                    throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Standalone generation returned an undeclared tool or invalid tool arguments.');
+                toolCalls.push({ name: event.name, callId: event.callId, arguments: event.arguments });
+            }
         }
         input.signal.throwIfAborted();
-        return completed && text ? { text, ...(usage === undefined ? {} : { usage }) } : undefined;
+        return completed && (text || toolCalls.length > 0)
+            ? {
+                text,
+                ...(toolCalls.length > 0 ? { toolCalls } : {}),
+                ...(usage === undefined ? {} : { usage })
+            }
+            : undefined;
     }
     finally {
         await adapter.close?.();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.10.20",
+  "version": "0.10.22",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",