@jsonstudio/rcc 0.90.352 → 0.90.364

package/vendor/@jsonstudio/llms/dist/bridge/routecodex-adapter.js

@@ -0,0 +1,229 @@
+const DEFAULT_ENDPOINT = '/v1/chat/completions';
+function isJsonObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function asJsonObject(value) {
+    return isJsonObject(value) ? value : undefined;
+}
+function readString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function generateRequestId() {
+    return `req_${Date.now()}_${Math.floor(Math.random() * 1_000_000)}`;
+}
+function normalizeEndpoint(candidate) {
+    if (candidate && candidate.trim()) {
+        return candidate.trim();
+    }
+    return DEFAULT_ENDPOINT;
+}
+function inferProviderType(protocol) {
+    const value = (protocol ?? '').toLowerCase();
+    if (value.includes('anthropic')) {
+        return 'anthropic';
+    }
+    if (value.includes('responses')) {
+        return 'responses';
+    }
+    if (value.includes('gemini')) {
+        return 'gemini';
+    }
+    return 'openai';
+}
+function buildContext(input) {
+    const envelope = input ?? {};
+    const route = asJsonObject(envelope.route);
+    const metadata = { ...(asJsonObject(envelope.metadata) ?? {}) };
+    const rootEntry = readString(envelope.entryEndpoint);
+    const routeId = readString(route?.requestId);
+    const dataWrapper = asJsonObject(envelope.data);
+    const dataEntry = readString(dataWrapper?.entryEndpoint);
+    const dataMeta = asJsonObject(dataWrapper?.metadata);
+    const metaEntry = readString(metadata.entryEndpoint);
+    const metaEndpoint = readString(metadata.endpoint);
+    const dataMetaEntry = readString(dataMeta?.entryEndpoint);
+    const endpoint = metaEndpoint ??
+        metaEntry ??
+        dataMetaEntry ??
+        dataEntry ??
+        rootEntry ??
+        DEFAULT_ENDPOINT;
+    const entryEndpoint = metaEntry ??
+        dataEntry ??
+        dataMetaEntry ??
+        rootEntry ??
+        endpoint;
+    const requestId = routeId ?? readString(metadata.requestId) ?? generateRequestId();
+    metadata.requestId = requestId;
+    metadata.endpoint = endpoint;
+    metadata.entryEndpoint = entryEndpoint;
+    return {
+        requestId,
+        endpoint: normalizeEndpoint(endpoint),
+        entryEndpoint: normalizeEndpoint(entryEndpoint),
+        metadata
+    };
+}
+function extractPayload(subject) {
+    if (!subject) {
+        return {};
+    }
+    if ('data' in subject && subject.data !== undefined) {
+        return subject.data;
+    }
+    if ('payload' in subject && subject.payload !== undefined) {
+        return subject.payload;
+    }
+    return subject;
+}
+function buildConversionEnvelope(payload, ctx, options, overrides) {
+    const endpoint = normalizeEndpoint(overrides?.endpoint ??
+        options?.entryEndpoint ??
+        ctx.entryEndpoint ??
+        ctx.endpoint);
+    const metadata = { ...ctx.metadata };
+    metadata.entryEndpoint = ctx.entryEndpoint || endpoint;
+    if (options?.processMode) {
+        metadata.processMode = options.processMode;
+    }
+    if (overrides?.metadata) {
+        Object.assign(metadata, overrides.metadata);
+    }
+    const providerProtocol = options?.providerProtocol ?? 'openai-chat';
+    const providerType = options?.providerType ?? inferProviderType(providerProtocol);
+    const streamSetting = metadata.stream;
+    const streamingFormat = streamSetting === true ? 'sse' : 'json';
+    return {
+        id: ctx.requestId || generateRequestId(),
+        timestamp: Date.now(),
+        endpoint,
+        payload,
+        metadata,
+        options: {
+            providerProtocol,
+            providerType,
+            processMode: options?.processMode,
+            streamingFormat,
+            stage: overrides?.stage ?? options?.stage,
+            direction: overrides?.direction ?? options?.direction
+        }
+    };
+}
+function prepareReturnPayload(envelope) {
+    return {
+        data: envelope.payload,
+        metadata: {
+            ...envelope.metadata,
+            conversionId: envelope.id,
+            conversionEndpoint: envelope.endpoint,
+            conversionStage: envelope.options.stage
+        }
+    };
+}
+class CoreAdapter {
+    options;
+    lastRequests = new Map();
+    constructor(opts) {
+        this.options = opts;
+    }
+    mergeOptions(opts) {
+        if (opts) {
+            this.options = { ...(this.options ?? {}), ...opts };
+        }
+    }
+    async processInboundRequest(request, opts) {
+        this.mergeOptions(opts);
+        const ctx = buildContext(request);
+        const body = extractPayload(request);
+        const entryEndpoint = opts?.entryEndpoint ?? ctx.entryEndpoint ?? ctx.endpoint;
+        const result = prepareReturnPayload(buildConversionEnvelope(body, ctx, { ...this.options, stage: 'inbound', direction: 'request' }, {
+            metadata: { direction: 'request' },
+            endpoint: entryEndpoint,
+            stage: 'inbound',
+            direction: 'request'
+        }));
+        this.lastRequests.set(ctx.requestId, body);
+        return result;
+    }
+    async processInboundResponse(response, opts) {
+        this.mergeOptions(opts);
+        const ctx = buildContext(response);
+        const body = extractPayload(response);
+        const entryEndpoint = opts?.entryEndpoint ?? ctx.entryEndpoint ?? ctx.endpoint;
+        const targetEndpoint = entryEndpoint.includes('#response')
+            ? entryEndpoint
+            : `${entryEndpoint}#response`;
+        return prepareReturnPayload(buildConversionEnvelope(body, ctx, { ...this.options, stage: 'inbound', direction: 'response' }, {
+            metadata: { direction: 'response' },
+            endpoint: targetEndpoint,
+            stage: 'inbound',
+            direction: 'response'
+        }));
+    }
+    async processOutboundRequest(request, opts) {
+        this.mergeOptions(opts);
+        const ctx = buildContext(request);
+        const body = extractPayload(request);
+        const entryEndpoint = opts?.entryEndpoint ?? ctx.entryEndpoint ?? ctx.endpoint;
+        return prepareReturnPayload(buildConversionEnvelope(body, ctx, { ...this.options, stage: 'outbound', direction: 'request' }, {
+            metadata: { direction: 'request' },
+            endpoint: entryEndpoint,
+            stage: 'outbound',
+            direction: 'request'
+        }));
+    }
+    async processOutboundResponse(response, opts) {
+        this.mergeOptions(opts);
+        const ctx = buildContext(response);
+        const body = extractPayload(response);
+        const entryEndpoint = opts?.entryEndpoint ?? ctx.entryEndpoint ?? ctx.endpoint;
+        const targetEndpoint = entryEndpoint.includes('#response')
+            ? entryEndpoint
+            : `${entryEndpoint}#response`;
+        const result = prepareReturnPayload(buildConversionEnvelope(body, ctx, { ...this.options, stage: 'outbound', direction: 'response' }, {
+            endpoint: targetEndpoint,
+            metadata: {
+                direction: 'response',
+                originalRequest: this.lastRequests.get(ctx.requestId) ?? {}
+            },
+            stage: 'outbound',
+            direction: 'response'
+        }));
+        return result;
+    }
+    async processIncoming(request, opts) {
+        return this.processInboundRequest(request, opts);
+    }
+    async processOutgoing(response, opts) {
+        const dto = await this.processOutboundResponse(response, opts);
+        return dto;
+    }
+}
+const singleton = new CoreAdapter();
+export async function processIncoming(request, options) {
+    return singleton.processIncoming(request, options);
+}
+export async function processOutgoing(response, options) {
+    return singleton.processOutgoing(response, options);
+}
+export async function processInboundRequest(request, options) {
+    return singleton.processInboundRequest(request, options);
+}
+export async function processInboundResponse(response, options) {
+    return singleton.processInboundResponse(response, options);
+}
+export async function processOutboundRequest(request, options) {
+    return singleton.processOutboundRequest(request, options);
+}
+export async function processOutboundResponse(response, options) {
+    const dto = await singleton.processOutboundResponse(response, options);
+    return dto;
+}
+export default {
+    processIncoming,
+    processOutgoing,
+    processInboundRequest,
+    processInboundResponse,
+    processOutboundRequest,
+    processOutboundResponse
+};

package/vendor/@jsonstudio/llms/dist/config-unified/enhanced-path-resolver.d.ts

@@ -0,0 +1,5 @@
+export interface ResolvedPaths {
+    hostRoot: string;
+    configDir: string;
+}
+export declare function resolveHostPaths(): ResolvedPaths;

package/vendor/@jsonstudio/llms/dist/config-unified/enhanced-path-resolver.js

@@ -0,0 +1,46 @@
+// Enhanced path resolver for host application roots and config directory
+// Strategy:
+// 1) Prefer process.cwd()/config when present
+// 2) If running from inside llmswitch-core dist, scan upward to find a dir that contains 'config'
+// 3) Fallback to 'config' relative to current module
+import path from 'path';
+import fs from 'fs';
+export function resolveHostPaths() {
+    // Attempt 1: process.cwd()
+    try {
+        const cwd = process.cwd();
+        const cfg = path.join(cwd, 'config');
+        if (fs.existsSync(cfg)) {
+            return { hostRoot: cwd, configDir: cfg };
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    // Attempt 2: scan upward from this file
+    try {
+        let cur = path.dirname(new URL(import.meta.url).pathname);
+        const visited = new Set();
+        for (let i = 0; i < 10; i++) {
+            if (visited.has(cur)) {
+                break;
+            }
+            visited.add(cur);
+            const cfg = path.join(cur, 'config');
+            if (fs.existsSync(cfg)) {
+                return { hostRoot: cur, configDir: cfg };
+            }
+            const parent = path.dirname(cur);
+            if (parent === cur) {
+                break;
+            }
+            cur = parent;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    // Fallback to relative 'config'
+    const fallbackRoot = process.cwd();
+    return { hostRoot: fallbackRoot, configDir: path.join(fallbackRoot, 'config') };
+}

package/vendor/@jsonstudio/llms/dist/config-unified/unified-config.d.ts

@@ -0,0 +1,26 @@
+export interface ContextBudget {
+    maxBytes: number;
+    safetyRatio: number;
+    allowedBytes: number;
+    source: string;
+}
+export declare class UnifiedConfigFacade {
+    private static _instance;
+    static getInstance(): UnifiedConfigFacade;
+    private watchers;
+    private fsWatcher;
+    getContextBudgetForModel(modelId: string): ContextBudget;
+    validateConfig(): {
+        ok: boolean;
+        issues: string[];
+    };
+    watchConfig(cb: (ev: {
+        file: string;
+        event: string;
+    }) => void): void;
+    unwatchConfig(cb?: (ev: {
+        file: string;
+        event: string;
+    }) => void): void;
+}
+export declare const UnifiedConfig: UnifiedConfigFacade;

package/vendor/@jsonstudio/llms/dist/config-unified/unified-config.js

@@ -0,0 +1,231 @@
+// Unified configuration facade (minimal, focused on context budget for Phase 1)
+import fs from 'fs';
+import path from 'path';
+import { resolveHostPaths } from './enhanced-path-resolver.js';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const hasProviders = (value) => isRecord(value) && typeof value.providers === 'object' && value.providers !== null;
+const readJsonSync = (file) => {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+};
+const listMergedConfigs = (configDir) => {
+    try {
+        const files = fs
+            .readdirSync(configDir)
+            .filter((name) => /merged-config.*\.json$/i.test(name))
+            .map((name) => path.join(configDir, name));
+        files.sort((a, b) => {
+            try {
+                const sa = fs.statSync(a);
+                const sb = fs.statSync(b);
+                return (sb.mtimeMs || 0) - (sa.mtimeMs || 0);
+            }
+            catch {
+                return 0;
+            }
+        });
+        return files;
+    }
+    catch {
+        return [];
+    }
+};
+const toNumber = (value) => {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+};
+const extractProviders = (cfg) => {
+    if (!isRecord(cfg.virtualrouter) || !hasProviders(cfg.virtualrouter)) {
+        return null;
+    }
+    return cfg.virtualrouter.providers ?? null;
+};
+const extractModulesConfig = (modulesRoot) => {
+    if (!isRecord(modulesRoot.modules)) {
+        return null;
+    }
+    const virtualRouterModule = modulesRoot.modules.virtualrouter;
+    if (!isRecord(virtualRouterModule)) {
+        return null;
+    }
+    const config = virtualRouterModule.config;
+    return isRecord(config) ? config : null;
+};
+const readContextBudgetNode = (configNode) => {
+    if (!configNode) {
+        return { defaultBytes: null, safetyRatio: null };
+    }
+    const contextBudgetNode = configNode.contextBudget;
+    if (!isRecord(contextBudgetNode)) {
+        return { defaultBytes: null, safetyRatio: null };
+    }
+    const defaultBytes = toNumber(contextBudgetNode.defaultMaxContextBytes ?? contextBudgetNode.defaultMaxContext);
+    const safetyRatio = toNumber(contextBudgetNode.safetyRatio);
+    return { defaultBytes, safetyRatio };
+};
+function findMaxContextInConfig(cfg, modelId) {
+    const providers = extractProviders(cfg);
+    if (!providers) {
+        return null;
+    }
+    for (const provider of Object.values(providers)) {
+        if (!isRecord(provider.models)) {
+            continue;
+        }
+        const models = provider.models;
+        if (!Object.prototype.hasOwnProperty.call(models, modelId)) {
+            continue;
+        }
+        const target = models[modelId];
+        if (!target) {
+            continue;
+        }
+        const maxContext = toNumber(target.maxContext);
+        if (maxContext && maxContext > 0) {
+            return maxContext;
+        }
+    }
+    return null;
+}
+export class UnifiedConfigFacade {
+    static _instance = null;
+    static getInstance() {
+        if (!this._instance) {
+            this._instance = new UnifiedConfigFacade();
+        }
+        return this._instance;
+    }
+    watchers = [];
+    fsWatcher = null;
+    // Phase 1: only context budget API
+    getContextBudgetForModel(modelId) {
+        const envDirect = Number(process.env.ROUTECODEX_CONTEXT_BUDGET_BYTES || process.env.RCC_CONTEXT_BUDGET_BYTES || '');
+        const envSafety = Number(process.env.RCC_CONTEXT_BUDGET_SAFETY || 'NaN');
+        const safetyFromEnv = (Number.isFinite(envSafety) && envSafety >= 0 && envSafety < 1) ? envSafety : NaN;
+        if (Number.isFinite(envDirect) && envDirect > 0) {
+            const safety = Number.isFinite(safetyFromEnv) ? safetyFromEnv : 0.1;
+            return { maxBytes: envDirect, safetyRatio: safety, allowedBytes: Math.floor(envDirect * (1 - safety)), source: 'env' };
+        }
+        const { configDir } = resolveHostPaths();
+        // modules.json defaults
+        let modulesDefault = null;
+        let modulesSafety = null;
+        try {
+            const modules = readJsonSync(path.join(configDir, 'modules.json'));
+            if (modules) {
+                const modulesConfig = extractModulesConfig(modules);
+                const { defaultBytes, safetyRatio } = readContextBudgetNode(modulesConfig);
+                if (defaultBytes && defaultBytes > 0) {
+                    modulesDefault = defaultBytes;
+                }
+                if (typeof safetyRatio === 'number' && safetyRatio >= 0 && safetyRatio < 1) {
+                    modulesSafety = safetyRatio;
+                }
+            }
+        }
+        catch { /* ignore */ }
+        // merged-config*.json
+        try {
+            const merged = listMergedConfigs(configDir);
+            for (const f of merged) {
+                const cfg = readJsonSync(f);
+                if (!cfg) {
+                    continue;
+                }
+                const v = findMaxContextInConfig(cfg, modelId);
+                if (v && v > 0) {
+                    const safety = Number.isFinite(safetyFromEnv) ? safetyFromEnv : (modulesSafety ?? 0.1);
+                    return { maxBytes: v, safetyRatio: safety, allowedBytes: Math.floor(v * (1 - safety)), source: `merged:${path.basename(f)}` };
+                }
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        // config.json
+        try {
+            const cfg = readJsonSync(path.join(configDir, 'config.json'));
+            if (cfg) {
+                const v = findMaxContextInConfig(cfg, modelId);
+                if (v && v > 0) {
+                    const safety = Number.isFinite(safetyFromEnv) ? safetyFromEnv : (modulesSafety ?? 0.1);
+                    return { maxBytes: v, safetyRatio: safety, allowedBytes: Math.floor(v * (1 - safety)), source: 'config.json' };
+                }
+            }
+        }
+        catch { /* ignore */ }
+        // fallback
+        const def = modulesDefault && modulesDefault > 0 ? modulesDefault : 200_000;
+        const safety = Number.isFinite(safetyFromEnv) ? safetyFromEnv : (modulesSafety ?? 0.1);
+        return { maxBytes: def, safetyRatio: safety, allowedBytes: Math.floor(def * (1 - safety)), source: (modulesDefault ? 'modules.json' : 'default') };
+    }
+    // Minimal schema check for contextBudget fields in modules.json (Phase 1 scope)
+    validateConfig() {
+        const issues = [];
+        try {
+            const { configDir } = resolveHostPaths();
+            const modules = readJsonSync(path.join(configDir, 'modules.json'));
+            if (modules) {
+                const modulesConfig = extractModulesConfig(modules);
+                if (modulesConfig && isRecord(modulesConfig.contextBudget)) {
+                    const contextBudget = modulesConfig.contextBudget;
+                    const defaultBytes = toNumber(contextBudget.defaultMaxContextBytes ?? contextBudget.defaultMaxContext);
+                    const safetyRatio = toNumber(contextBudget.safetyRatio);
+                    if (!(defaultBytes && defaultBytes > 0)) {
+                        issues.push('contextBudget.defaultMaxContextBytes must be positive number');
+                    }
+                    if (!(typeof safetyRatio === 'number' && safetyRatio >= 0 && safetyRatio < 1)) {
+                        issues.push('contextBudget.safetyRatio must be in [0,1)');
+                    }
+                }
+            }
+        }
+        catch (error) {
+            const err = error;
+            issues.push(`validateConfig error: ${err?.message ?? String(error)}`);
+        }
+        return { ok: issues.length === 0, issues };
+    }
+    watchConfig(cb) {
+        this.watchers.push(cb);
+        if (this.fsWatcher) {
+            return;
+        }
+        try {
+            const { configDir } = resolveHostPaths();
+            this.fsWatcher = fs.watch(configDir, { persistent: false }, (event, file) => {
+                try {
+                    this.watchers.forEach((fn) => fn({ file: file || '', event }));
+                }
+                catch {
+                    /* ignore */
+                }
+            });
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    unwatchConfig(cb) {
+        if (!cb) {
+            this.watchers = [];
+        }
+        else {
+            this.watchers = this.watchers.filter((fn) => fn !== cb);
+        }
+        if (this.watchers.length === 0 && this.fsWatcher) {
+            try {
+                this.fsWatcher.close();
+            }
+            catch {
+                /* ignore */
+            }
+            this.fsWatcher = null;
+        }
+    }
+}
+export const UnifiedConfig = UnifiedConfigFacade.getInstance();

package/vendor/@jsonstudio/llms/dist/conversion/args-mapping.d.ts

@@ -0,0 +1,18 @@
+export type Unknown = Record<string, unknown>;
+export interface NormalizeResult<T = Record<string, unknown>> {
+    ok: boolean;
+    value?: T;
+    errors?: string[];
+}
+type JsonSchema = {
+    type?: string | string[];
+    properties?: Record<string, JsonSchema & {
+        ['x-aliases']?: string[];
+    }>;
+    required?: string[];
+    items?: JsonSchema;
+    additionalProperties?: boolean;
+};
+export declare function normalizeArgsBySchema(input: any, schema?: JsonSchema): NormalizeResult;
+export declare function normalizeTools(tools: any[]): Unknown[];
+export {};

package/vendor/@jsonstudio/llms/dist/conversion/args-mapping.js

@@ -0,0 +1,8 @@
+import { normalizeArgsBySchemaWithNative, normalizeToolsWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function normalizeArgsBySchema(input, schema) {
+    return normalizeArgsBySchemaWithNative(input, schema);
+}
+// Tools normalizer (OpenAI-like)
+export function normalizeTools(tools) {
+    return normalizeToolsWithNative(tools);
+}

package/vendor/@jsonstudio/llms/dist/conversion/bridge-actions.d.ts

@@ -0,0 +1,39 @@
+type UnknownRecord = Record<string, unknown>;
+export type BridgeActionStage = 'request_inbound' | 'request_outbound' | 'response_inbound' | 'response_outbound';
+export interface BridgeActionDescriptor {
+    name: string;
+    options?: Record<string, unknown>;
+}
+export interface BridgeActionState {
+    messages: Array<UnknownRecord>;
+    requiredAction?: UnknownRecord;
+    capturedToolResults?: Array<{
+        tool_call_id?: string;
+        call_id?: string;
+        output?: unknown;
+        name?: string;
+    }>;
+    rawRequest?: UnknownRecord;
+    rawResponse?: UnknownRecord;
+    metadata?: Record<string, unknown>;
+}
+export interface BridgeActionContext {
+    stage: BridgeActionStage;
+    protocol?: string;
+    moduleType?: string;
+    requestId?: string;
+    descriptor: BridgeActionDescriptor;
+    state: BridgeActionState;
+}
+export type BridgeAction = (context: BridgeActionContext) => void;
+export declare function registerBridgeAction(name: string, action: BridgeAction): void;
+export declare function createBridgeActionState(seed?: Partial<BridgeActionState>): BridgeActionState;
+export declare function runBridgeActionPipeline(options: {
+    stage: BridgeActionStage;
+    actions?: BridgeActionDescriptor[];
+    protocol?: string;
+    moduleType?: string;
+    requestId?: string;
+    state: BridgeActionState;
+}): void;
+export {};

package/vendor/@jsonstudio/llms/dist/conversion/bridge-actions.js

@@ -0,0 +1,82 @@
+import { runBridgeActionPipelineWithNative } from '../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
+const registry = new Map();
+export function registerBridgeAction(name, action) {
+    registry.set(name, action);
+}
+export function createBridgeActionState(seed) {
+    const state = {
+        messages: Array.isArray(seed?.messages) ? seed.messages : []
+    };
+    if (seed?.requiredAction)
+        state.requiredAction = seed.requiredAction;
+    if (seed?.capturedToolResults)
+        state.capturedToolResults = seed.capturedToolResults;
+    if (seed?.rawRequest)
+        state.rawRequest = seed.rawRequest;
+    if (seed?.rawResponse)
+        state.rawResponse = seed.rawResponse;
+    if (seed?.metadata)
+        state.metadata = seed.metadata;
+    return state;
+}
+export function runBridgeActionPipeline(options) {
+    const { stage, actions, protocol, moduleType, requestId, state } = options;
+    if (!actions?.length)
+        return;
+    const output = runBridgeActionPipelineWithNative({
+        stage,
+        actions: actions.map((entry) => ({
+            name: entry.name,
+            options: entry.options
+        })),
+        protocol,
+        moduleType,
+        requestId,
+        state: state
+    });
+    if (!output) {
+        return;
+    }
+    if (output && typeof output === 'object') {
+        const next = output;
+        const patch = {
+            messages: Array.isArray(next.messages) ? next.messages : state.messages,
+            ...(next.requiredAction && typeof next.requiredAction === 'object' && !Array.isArray(next.requiredAction)
+                ? { requiredAction: next.requiredAction }
+                : {}),
+            ...(Array.isArray(next.capturedToolResults)
+                ? { capturedToolResults: next.capturedToolResults }
+                : {}),
+            ...(next.rawRequest && typeof next.rawRequest === 'object' && !Array.isArray(next.rawRequest)
+                ? { rawRequest: next.rawRequest }
+                : {}),
+            ...(next.rawResponse && typeof next.rawResponse === 'object' && !Array.isArray(next.rawResponse)
+                ? { rawResponse: next.rawResponse }
+                : {}),
+            ...(next.metadata && typeof next.metadata === 'object' && !Array.isArray(next.metadata)
+                ? { metadata: next.metadata }
+                : {})
+        };
+        Object.assign(state, patch);
+    }
+    for (const descriptor of actions) {
+        if (!descriptor || typeof descriptor !== 'object')
+            continue;
+        const action = registry.get(descriptor.name);
+        if (!action)
+            continue;
+        try {
+            action({
+                stage,
+                protocol,
+                moduleType,
+                requestId,
+                descriptor,
+                state
+            });
+        }
+        catch {
+            // Ignore action failures to preserve core flow; telemetry hooks can be added later.
+        }
+    }
+}