@myagentroam/agent 0.9.141 → 0.9.143

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

@@ -0,0 +1,63 @@
+import { MarAgentError } from '../error.js';
+import { resolveModelDefaultReasoningEffort } from '../model/configuration.js';
+export function resolveAgentModels(configurations, requestedDefaultModelId) {
+    const configuredModels = configurations.map((model) => ({
+        ...model,
+        defaultReasoningEffort: resolveModelDefaultReasoningEffort(model)
+    }));
+    const credentialProviders = new Set();
+    for (const model of configuredModels) {
+        if ((model.apiKey === undefined) === (model.credentialProvider === undefined))
+            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Exactly one model credential source is required.');
+        if (model.responsesEncoding !== undefined &&
+            (model.protocol !== 'OPENAI_RESPONSES' ||
+                !['STANDARD', 'LITE'].includes(model.responsesEncoding)))
+            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Responses encoding is invalid.');
+        if (model.fastMode === true && model.protocol !== 'OPENAI_RESPONSES')
+            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Fast mode requires Responses.');
+        if (model.serviceTier !== undefined &&
+            (model.protocol !== 'OPENAI_RESPONSES' ||
+                !['auto', 'default', 'flex', 'priority', 'fast', 'ultrafast'].includes(model.serviceTier)))
+            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Responses service tier is invalid.');
+        if (model.credentialProvider !== undefined)
+            credentialProviders.add(model.credentialProvider);
+    }
+    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.');
+    return { models, defaultModelId, credentialProviders };
+}
+export function createModelTurnSession(adapter) {
+    const turn = adapter.createTurnSession?.() ?? {
+        start: (request, signal) => adapter.start(request, signal),
+        close: async () => undefined
+    };
+    return {
+        async *start(request, signal) {
+            const before = request.retryState?.attempts;
+            try {
+                yield* turn.start(request, signal);
+            }
+            finally {
+                // Custom adapters may not participate in the shared attempt accounting.
+                if (request.retryState && request.retryState.attempts === before)
+                    request.retryState.attempts++;
+            }
+        },
+        resetContinuation: () => turn.resetContinuation?.(),
+        close: () => turn.close()
+    };
+}
+export async function closeModelAdapters(adapters) {
+    const results = await Promise.allSettled([...new Set(adapters)].flatMap((adapter) => adapter.close === undefined ? [] : [adapter.close()]));
+    const failure = results.find((result) => result.status === 'rejected');
+    if (failure !== undefined)
+        throw failure.reason;
+}
+export function addModelCredentialProviders(target, configuration) {
+    if (configuration.credentialProvider !== undefined)
+        target.add(configuration.credentialProvider);
+}

package/dist/agent-core/sdk/session-title.d.ts

@@ -0,0 +1,3 @@
+import type { MarAgentReasoningEffort } from '../model/configuration.js';
+import type { ModelAdapter, ModelAttemptDiagnostic } from '../model/contracts.js';
+export declare function generateSessionTitle(adapter: ModelAdapter, prompt: string, reasoningEffort: MarAgentReasoningEffort, signal: AbortSignal, onAttemptDiagnostic: (diagnostic: ModelAttemptDiagnostic) => Promise<void> | void): Promise<string | undefined>;

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

@@ -0,0 +1,42 @@
+import { sessionTitlePrompt } from '../prompts/title.js';
+import { createModelTurnSession } from './model-runtime.js';
+export async function generateSessionTitle(adapter, prompt, reasoningEffort, signal, onAttemptDiagnostic) {
+    let titleInput = '';
+    let characters = 0;
+    for (const character of prompt) {
+        if (characters++ >= 1000)
+            break;
+        titleInput += character;
+    }
+    let output = '';
+    let completed = false;
+    const turn = createModelTurnSession(adapter);
+    try {
+        for await (const event of turn.start({
+            retryState: { attempts: 0, maxAttempts: 1 },
+            system: sessionTitlePrompt,
+            messages: [{ role: 'user', content: titleInput }],
+            tools: [],
+            reasoningEffort,
+            onAttemptDiagnostic
+        }, signal)) {
+            if (event.type === 'text.completed')
+                output = event.text;
+            else if (event.type === 'completed')
+                completed = event.reason === 'completed';
+        }
+    }
+    finally {
+        await turn.close();
+    }
+    if (!completed)
+        return undefined;
+    const line = output
+        .replace(/<think>[\s\S]*?<\/think>\s*/giu, '')
+        .split(/\r?\n/u)
+        .map((value) => value.trim())
+        .find(Boolean);
+    if (!line)
+        return undefined;
+    return [...line].slice(0, 50).join('');
+}

package/dist/agent-core/sdk/session.d.ts

@@ -0,0 +1,62 @@
+import type { ContextualWorldState } from '../runtime/context/world-state.js';
+import type { ResolvedModelConfiguration } from './model-runtime.js';
+import type { HostDescription, MarAgentHost } from '../host/contracts.js';
+import { type MarAgentReasoningEffort } from '../model/configuration.js';
+import type { ModelAdapter } from '../model/contracts.js';
+import { RolloutBudget, resolveRolloutBudgetOptions } from '../runtime/rollout-budget.js';
+import { JsonlSessionStore } from '../session/jsonl-store.js';
+import { SubagentSessionController, type SubagentMailboxMessage, type SubagentMessageDelivery, type SubagentTurnHandle } from '../subagent/session-controller.js';
+import { createSessionToolScheduler } from '../tools/scheduler.js';
+import { TodoStore } from '../tools/agent/todo.js';
+import type { CreateMarAgentOptions, ExecutionResult, MarAgentSession } from './types.js';
+export interface SessionRuntime {
+    todo?: TodoStore;
+    readonly scheduleTool: ReturnType<typeof createSessionToolScheduler>;
+    readonly sourceType: 'user' | 'subagent';
+    adapterGeneration: number;
+    adapters: Map<string, ModelAdapter>;
+    contextualWorldState?: ContextualWorldState;
+    subagents?: SubagentSessionController;
+    subagentsOpening?: Promise<SubagentSessionController>;
+}
+interface InternalMarAgentSession extends MarAgentSession {
+    startSubagentTurn(input: {
+        readonly prompt: string;
+        readonly modelId: string;
+        readonly reasoningEffort: MarAgentReasoningEffort;
+        readonly role: 'general-purpose' | 'explore';
+        readonly initialMailbox: readonly SubagentMailboxMessage[];
+        readonly turnId: string;
+        readonly delivery?: SubagentMessageDelivery;
+        readonly sharedRolloutBudget?: RolloutBudget;
+        readonly mcpExecutionScopeId: string;
+    }): SubagentTurnHandle;
+}
+/** Agent-owned registries shared with Session orchestration, not public execution state. */
+export interface AgentSessionRegistry {
+    readonly active: Map<string, AbortController>;
+    readonly activeExecutionAdapters: Set<ModelAdapter>;
+    readonly executionResults: Map<string, Promise<ExecutionResult>>;
+    readonly sessionRuntimes: Map<string, SessionRuntime>;
+    readonly sessionWriterOwner: object;
+}
+interface SessionServices {
+    readonly host: MarAgentHost;
+    readonly description: HostDescription;
+    readonly settings: Pick<CreateMarAgentOptions, 'workspaceMapping' | 'systemInstruction'>;
+    readonly store: JsonlSessionStore;
+    readonly registry: AgentSessionRegistry;
+    readonly rolloutBudgetOptions: ReturnType<typeof resolveRolloutBudgetOptions>;
+    readonly hasCustomAdapters: boolean;
+    readonly modelState: () => {
+        readonly models: ReadonlyMap<string, ResolvedModelConfiguration>;
+        readonly defaultModelId: string;
+        readonly generation: number;
+    };
+    readonly createAdapter: (modelId: string, models: ReadonlyMap<string, ResolvedModelConfiguration>) => ModelAdapter;
+    readonly activeAdaptersExcept: (sessionId: string) => ReadonlySet<ModelAdapter>;
+    readonly assertCanStart: () => void;
+}
+/** SDK Session orchestration owns warm resources; Runtime owns only the model/tool loop. */
+export declare function createSessionOpener(services: SessionServices): (sessionId: string, workspace?: string) => Promise<InternalMarAgentSession>;
+export {};