maka-agent 0.2.0-dev.3.20260830 → 0.2.0-dev.30.20260912

package/node_modules/@maka/runtime/dist/request-shape.js

@@ -18,6 +18,8 @@
  */
 import { Buffer } from 'node:buffer';
 import { createHash } from 'node:crypto';
+import { PREPARED_REQUEST_OBSERVATION_TEXT_MAX_LENGTH, } from '@maka/core/model-call-attempt';
+import { foldPromptComposition } from './prompt-composition.js';
 import { toJSONSchema } from 'zod';
 /**
  * Split the registry into the full dispatch set (`providerTools`) and the
@@ -46,39 +48,6 @@ export function canonicalizeToolSet(tools, invalidTool, activeNames) {
         activeTools,
     };
 }
-export function computeRequestShapeDiagnostic(input, prior) {
-    const componentHashes = {
-        modelProviderHash: stableHash({
-            providerId: input.connection.providerType,
-            connectionSlug: input.connection.slug,
-            modelId: input.modelId,
-        }),
-        systemPromptHash: stableHash(input.systemPrompt ?? ''),
-        providerOptionsHash: stableHash(input.providerOptions ?? {}),
-        toolSchemaHash: stableHash({
-            activeTools: [...input.activeTools],
-            // Only the provider-visible (active) subset crosses the wire, so the
-            // schema hash must reflect that subset — otherwise an inactive deferred
-            // tool's schema change would falsely fire `tool_schema_changed`, and a
-            // load would not be distinguishable from churn.
-            providerTools: providerVisibleTools(input.providerTools, input.activeTools).map(toolShapeForDiagnostics),
-        }),
-        historyProjectionHash: stableHash(input.priorMessages.map(messageShapeForHash)),
-    };
-    const durablePrefixComponents = durableComponents(componentHashes);
-    const prefixHash = stableHash(durablePrefixComponents);
-    const requestShapeHash = stableHash(componentHashes);
-    const toolSchemaChangeReason = classifyToolSchemaChange(componentHashes, prior?.componentHashes, input.toolAvailability, prior?.toolAvailability);
-    return {
-        prefixHash,
-        prefixChangeReason: classifyDurablePrefixChange(durablePrefixComponents, prior ? durableComponents(prior.componentHashes) : undefined),
-        requestShapeHash,
-        requestShapeChangeReason: classifyRequestShapeChange(componentHashes, prior?.componentHashes),
-        componentHashes,
-        ...(toolSchemaChangeReason !== undefined ? { toolSchemaChangeReason } : {}),
-        ...(input.toolAvailability !== undefined ? { toolAvailability: input.toolAvailability } : {}),
-    };
-}
 export function toolSchemaCharsForDiagnostics(providerTools, activeTools) {
     return stableStringify({
         activeTools: [...activeTools],
@@ -86,248 +55,89 @@ export function toolSchemaCharsForDiagnostics(providerTools, activeTools) {
     }).length;
 }
 /**
- * Capture the standardized request immediately before the provider call.
+ * Observe the standardized request at the AI SDK model-call seam.
  *
- * Segment order follows the stable Maka request-prefix model used for cache
- * diagnostics: tools, system instructions, then conversation messages.
- * Provider options are retained for exact replay evidence, but are not claimed
- * to be a provider-cacheable prefix segment.
+ * Segment order follows Maka's semantic request-prefix model: tools, system
+ * instructions, then conversation messages. Provider options are retained for
+ * exact request evidence, but are not claimed to be a provider-cacheable prefix
+ * segment. None of this is presented as the provider's final wire body.
  */
-export function capturePreparedProviderRequest(input) {
-    const payload = input.requestPayload ?? {
-        instructions: input.instructions,
-        messages: input.messages,
-        tools: input.tools ?? [],
-        providerOptions: input.providerOptions ?? {},
-    };
-    // This is the evidence body, not the hash canonicalizer: preserve the exact
-    // JSON ordering and values presented at the model-call seam.
-    const serializedRequest = JSON.stringify(payload);
+export function preparedPromptComposition(payload) {
     const segments = [];
-    for (const [index, tool] of (input.tools ?? []).entries()) {
-        segments.push(preparedSegment('tool_schema', index, tool, true, undefined, toolLabel(tool)));
-    }
-    if (input.instructions !== undefined) {
-        const instructions = Array.isArray(input.instructions)
-            ? input.instructions
-            : [input.instructions];
-        for (const [index, instruction] of instructions.entries()) {
-            segments.push(preparedSegment('system_prompt', index, instruction, true));
-        }
+    const parts = semanticRequestParts(payload);
+    for (const tool of parts.tools)
+        segments.push(sizedSegment('tool_schema', tool, toolLabel(tool)));
+    if (parts.instructions !== undefined) {
+        const instructions = Array.isArray(parts.instructions)
+            ? parts.instructions
+            : [parts.instructions];
+        for (const instruction of instructions)
+            segments.push(sizedSegment('system_prompt', instruction));
     }
-    for (const [index, message] of input.messages.entries()) {
-        const role = isObjectLike(message) && typeof message.role === 'string' ? message.role : undefined;
-        segments.push(preparedSegment('message', index, message, true, role));
+    for (const message of parts.messages)
+        segments.push(sizedSegment('message', message));
+    if (parts.providerOptions !== undefined) {
+        segments.push(sizedSegment('provider_options', parts.providerOptions));
     }
-    if (input.providerOptions !== undefined) {
-        segments.push(preparedSegment('provider_options', 0, input.providerOptions, false));
-    }
-    return {
-        schemaVersion: 2,
-        requestHash: stableHash({
-            providerId: input.providerId,
-            modelId: input.modelId,
-            payload,
-        }),
-        requestPayloadWithoutProviderOptionsHash: stableHash(protocolIndependentRequestPayload(payload)),
-        requestBytes: Buffer.byteLength(serializedRequest, 'utf8'),
-        serializedRequest,
-        segments,
-    };
+    // Folded here rather than stored part by part. The fold is bounded by its own
+    // output — four kinds and a capped tool list — so the unbounded segment list
+    // never leaves this function and needs no cap of its own.
+    return foldPromptComposition(segments);
 }
-function protocolIndependentRequestPayload(payload) {
-    if (!isObjectLike(payload))
-        return payload;
-    const { providerOptions, ...shared } = payload;
-    const identities = {
-        approvalIds: new Map(),
-        toolCallIds: new Map(),
-    };
-    const reasoningEffort = protocolIndependentReasoningEffort(providerOptions);
-    const protocolIndependent = {
-        ...shared,
-        ...(Array.isArray(shared.prompt)
-            ? {
-                prompt: shared.prompt.map((message) => withoutPromptProviderOptions(message, identities)),
-            }
-            : {}),
-        ...(Array.isArray(shared.messages)
-            ? {
-                messages: shared.messages.map((message) => withoutPromptProviderOptions(message, identities)),
-            }
-            : {}),
-        ...(Array.isArray(shared.tools)
-            ? { tools: shared.tools.map(withoutObjectProviderOptions) }
+function sizedSegment(kind, value, label) {
+    const serialized = JSON.stringify(normalizePreparedValue(value));
+    return {
+        kind,
+        bytes: Buffer.byteLength(serialized, 'utf8'),
+        ...(label !== undefined
+            ? { label: label.slice(0, PREPARED_REQUEST_OBSERVATION_TEXT_MAX_LENGTH) }
             : {}),
-        ...(reasoningEffort !== undefined ? { reasoningEffort } : {}),
     };
-    const thinkingBudget = anthropicThinkingBudget(providerOptions);
-    if (thinkingBudget === undefined ||
-        !isNonNegativeSafeInteger(protocolIndependent.maxOutputTokens)) {
-        return protocolIndependent;
-    }
-    const wireOutputLimit = protocolIndependent.maxOutputTokens + thinkingBudget;
-    return Number.isSafeInteger(wireOutputLimit)
-        ? { ...protocolIndependent, maxOutputTokens: wireOutputLimit }
-        : protocolIndependent;
 }
-function protocolIndependentReasoningEffort(providerOptions) {
-    if (!isObjectLike(providerOptions))
-        return undefined;
-    const efforts = new Set();
-    const anthropic = providerOptions.anthropic;
-    if (isObjectLike(anthropic) && typeof anthropic.effort === 'string') {
-        efforts.add(anthropic.effort);
+function semanticRequestParts(payload) {
+    if (!isObjectLike(payload)) {
+        return { messages: [], tools: [] };
     }
-    for (const namespace of Object.values(providerOptions)) {
-        if (!isObjectLike(namespace))
-            continue;
-        if (typeof namespace.reasoningEffort === 'string')
-            efforts.add(namespace.reasoningEffort);
-        if (isObjectLike(namespace.thinking) && namespace.thinking.type === 'disabled') {
-            efforts.add('none');
-        }
-        const thinkingConfig = namespace.thinkingConfig;
-        if (isObjectLike(thinkingConfig) && typeof thinkingConfig.thinkingLevel === 'string') {
-            efforts.add(thinkingConfig.thinkingLevel);
-        }
-        if (isObjectLike(thinkingConfig) && thinkingConfig.thinkingBudget === 0) {
-            efforts.add('none');
-        }
-        const chatTemplateKwargs = namespace.chat_template_kwargs;
-        if (isObjectLike(chatTemplateKwargs) && chatTemplateKwargs.thinking === false) {
-            efforts.add('none');
+    const prompt = Array.isArray(payload.prompt) ? payload.prompt : undefined;
+    const instructions = [];
+    const messages = [];
+    if (prompt) {
+        for (const item of prompt) {
+            const record = isObjectLike(item) ? item : undefined;
+            if (record?.role === 'system')
+                instructions.push(record.content);
+            else
+                messages.push(item);
         }
     }
-    const normalized = [...efforts].sort();
-    return normalized.length > 1 ? normalized : normalized[0];
-}
-function withoutPromptProviderOptions(value, identities) {
-    const message = withoutObjectProviderOptions(value);
-    if (!isObjectLike(message) || !Array.isArray(message.content))
-        return message;
+    const payloadMessages = Array.isArray(payload.messages) ? payload.messages : undefined;
+    const providerOptions = isPlainObject(payload.providerOptions)
+        ? payload.providerOptions
+        : undefined;
     return {
-        ...message,
-        content: message.content.map((part) => withoutPromptPartProviderOptions(part, identities)),
+        ...(prompt
+            ? instructions.length > 0
+                ? { instructions }
+                : {}
+            : payload.instructions !== undefined
+                ? { instructions: payload.instructions }
+                : {}),
+        messages: prompt ? messages : (payloadMessages ?? []),
+        tools: Array.isArray(payload.tools) ? payload.tools : [],
+        ...(providerOptions !== undefined ? { providerOptions } : {}),
     };
 }
-function withoutPromptPartProviderOptions(value, identities) {
-    const part = withoutObjectProviderOptions(value);
-    if (!isObjectLike(part))
-        return part;
-    if (part.type === 'tool-call') {
-        const { providerExecuted: _providerExecuted, ...shared } = part;
-        return {
-            ...shared,
-            toolCallId: protocolIndependentId(part.toolCallId, identities.toolCallIds, 'tool-call'),
-        };
-    }
-    if (part.type === 'tool-approval-request') {
-        const { isAutomatic: _isAutomatic, signature: _signature, ...shared } = part;
-        return {
-            ...shared,
-            approvalId: protocolIndependentId(part.approvalId, identities.approvalIds, 'approval'),
-            toolCallId: protocolIndependentId(part.toolCallId, identities.toolCallIds, 'tool-call'),
-        };
-    }
-    if (part.type === 'tool-approval-response') {
-        const { providerExecuted: _providerExecuted, ...shared } = part;
-        return {
-            ...shared,
-            approvalId: protocolIndependentId(part.approvalId, identities.approvalIds, 'approval'),
-        };
-    }
-    if (part.type !== 'tool-result')
-        return part;
-    const output = withoutObjectProviderOptions(part.output);
-    const normalizedPart = {
-        ...part,
-        toolCallId: protocolIndependentId(part.toolCallId, identities.toolCallIds, 'tool-call'),
-    };
-    if (!isObjectLike(output) || output.type !== 'content' || !Array.isArray(output.value)) {
-        return { ...normalizedPart, output };
-    }
-    return {
-        ...normalizedPart,
-        output: { ...output, value: output.value.map(withoutObjectProviderOptions) },
-    };
-}
-function protocolIndependentId(value, identities, prefix) {
-    if (typeof value !== 'string')
-        return value;
-    const existing = identities.get(value);
-    if (existing)
-        return existing;
-    const normalized = `${prefix}-${identities.size + 1}`;
-    identities.set(value, normalized);
-    return normalized;
-}
-function withoutObjectProviderOptions(value) {
-    if (!isObjectLike(value))
-        return value;
-    const { providerOptions: _providerOptions, ...shared } = value;
-    return shared;
-}
-function anthropicThinkingBudget(providerOptions) {
-    if (!isObjectLike(providerOptions))
-        return undefined;
-    const anthropic = providerOptions.anthropic;
-    if (!isObjectLike(anthropic))
-        return undefined;
-    const thinking = anthropic.thinking;
-    if (!isObjectLike(thinking) || thinking.type !== 'enabled')
-        return undefined;
-    return isNonNegativeSafeInteger(thinking.budgetTokens) ? thinking.budgetTokens : undefined;
-}
-function isNonNegativeSafeInteger(value) {
-    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
-}
-export function findFirstChangedCacheableSegment(current, prior) {
-    const currentSegments = current.segments.filter((segment) => segment.cacheable);
-    const priorSegments = prior.segments.filter((segment) => segment.cacheable);
-    const segmentCount = Math.max(currentSegments.length, priorSegments.length);
-    for (let position = 0; position < segmentCount; position += 1) {
-        const currentSegment = currentSegments[position];
-        const priorSegment = priorSegments[position];
-        if (currentSegment?.kind === priorSegment?.kind &&
-            currentSegment?.index === priorSegment?.index &&
-            currentSegment?.hash === priorSegment?.hash) {
-            continue;
-        }
-        const changed = currentSegment ?? priorSegment;
-        if (!changed)
-            return undefined;
-        return {
-            kind: changed.kind,
-            index: changed.index,
-            ...(changed.role !== undefined ? { role: changed.role } : {}),
-        };
-    }
-    return undefined;
-}
 /** The provider-visible tools — the active subset actually serialized on the wire. */
 function providerVisibleTools(providerTools, activeTools) {
     const active = new Set(activeTools);
     return providerTools.filter((tool) => active.has(tool.name));
 }
-function preparedSegment(kind, index, value, cacheable, role, label) {
-    const serialized = stableStringify(value);
-    return {
-        kind,
-        index,
-        cacheable,
-        hash: stableHash(value),
-        bytes: Buffer.byteLength(serialized, 'utf8'),
-        ...(role !== undefined ? { role } : {}),
-        ...(label !== undefined ? { label } : {}),
-    };
-}
 /**
  * The tool's own name as the payload carries it.
  *
- * Read off the serialized tool rather than the registry: this capture describes
- * what crossed the wire, so a name that is not in the payload is not a name this
- * segment can claim.
+ * Read off the prepared payload rather than the registry: this observation
+ * describes what Maka handed to the model-call seam, so a name absent there is
+ * not a name this segment can claim.
  */
 function toolLabel(tool) {
     if (!isObjectLike(tool))
@@ -342,87 +152,135 @@ export function toolCatalogHash(tools) {
         .sort((left, right) => (left.name < right.name ? -1 : left.name > right.name ? 1 : 0))
         .map(toolShapeForDiagnostics));
 }
+/** Canonical, JSON-safe schemas for the exact provider-visible tool subset. */
+export function requestCompositionToolSchemas(tools, activeToolNames) {
+    const active = new Set(activeToolNames);
+    return tools
+        .filter((tool) => active.has(tool.name))
+        .map((tool) => {
+        const inputSchema = JSON.parse(stableStringify(schemaShapeForHash(tool.parameters)));
+        if (!isPlainObject(inputSchema)) {
+            throw new Error(`Tool ${JSON.stringify(tool.name)} produced a non-object input schema`);
+        }
+        return {
+            name: tool.name,
+            description: tool.description,
+            inputSchema,
+            ...(tool.providerTool
+                ? {
+                    providerTool: JSON.parse(stableStringify(tool.providerTool)),
+                }
+                : {}),
+        };
+    })
+        .sort((left, right) => (left.name < right.name ? -1 : left.name > right.name ? 1 : 0));
+}
 export function stableStringify(value) {
     return JSON.stringify(canonicalize(value));
 }
-function classifyDurablePrefixChange(current, prior) {
-    if (!prior)
-        return 'first_turn';
-    if (current.modelProviderHash !== prior.modelProviderHash)
-        return 'model_or_provider_changed';
-    if (current.systemPromptHash !== prior.systemPromptHash)
-        return 'system_prompt_changed';
-    if (current.toolSchemaHash !== prior.toolSchemaHash)
-        return 'tool_schema_changed';
-    if (current.providerOptionsHash !== prior.providerOptionsHash)
-        return 'provider_options_changed';
-    return 'stable';
-}
-function classifyRequestShapeChange(current, prior) {
-    if (!prior)
-        return 'first_turn';
-    if (current.modelProviderHash !== prior.modelProviderHash)
-        return 'model_or_provider_changed';
-    if (current.systemPromptHash !== prior.systemPromptHash)
-        return 'system_prompt_changed';
-    if (current.toolSchemaHash !== prior.toolSchemaHash)
-        return 'tool_schema_changed';
-    if (current.providerOptionsHash !== prior.providerOptionsHash)
-        return 'provider_options_changed';
-    if (current.historyProjectionHash !== prior.historyProjectionHash)
-        return 'history_projection_changed';
-    return 'stable';
-}
-function classifyToolSchemaChange(current, prior, currentAvail, priorAvail) {
-    if (!prior || current.toolSchemaHash === prior.toolSchemaHash)
-        return undefined;
-    if (isEnabledSourceStrictSuperset(currentAvail, priorAvail) &&
-        sourceCatalogStable(currentAvail, priorAvail)) {
-        return 'tool_source_enabled';
-    }
-    if (sourceStateChanged(currentAvail, priorAvail)) {
-        return 'tool_source_state_changed';
-    }
-    return 'tool_schema_changed';
-}
-function isEnabledSourceStrictSuperset(current, prior) {
-    if (!current ||
-        !prior ||
-        current.mode !== prior.mode ||
-        (current.mode !== 'economy' && current.mode !== 'search'))
-        return false;
-    const currentIds = new Set(current.enabledSourceIds);
-    const priorIds = new Set(prior.enabledSourceIds);
-    if (currentIds.size <= priorIds.size)
-        return false;
-    for (const sourceId of priorIds) {
-        if (!currentIds.has(sourceId))
-            return false;
-    }
-    return true;
-}
-function sourceCatalogStable(current, prior) {
-    if (!current || !prior)
-        return false;
-    return (stableStringify(sourceCatalogShape(current)) === stableStringify(sourceCatalogShape(prior)));
-}
-function sourceStateChanged(current, prior) {
-    return stableStringify(current ?? null) !== stableStringify(prior ?? null);
-}
-function sourceCatalogShape(diagnostic) {
-    return {
-        mode: diagnostic.mode,
-        connectorToolName: diagnostic.connectorToolName,
-        visibleToolNamesBySource: diagnostic.visibleToolNamesBySource ?? {},
-    };
-}
-function durableComponents(components) {
-    return {
-        modelProviderHash: components.modelProviderHash,
-        systemPromptHash: components.systemPromptHash,
-        providerOptionsHash: components.providerOptionsHash,
-        toolSchemaHash: components.toolSchemaHash,
+/**
+ * Lossless JSON representation for the semantic values accepted by the model
+ * seam. Every value is tagged, so a bigint cannot collide with a user string
+ * and an undefined property cannot disappear, and values that cannot be
+ * described exactly are kept as explicit markers rather than dropped — a size
+ * taken from this covers the whole payload.
+ */
+function normalizePreparedValue(value) {
+    const tag = '__makaPreparedValue';
+    const ancestors = new Set();
+    const visit = (current, depth) => {
+        if (current === null || typeof current === 'string' || typeof current === 'boolean') {
+            return current;
+        }
+        if (typeof current === 'number') {
+            if (Number.isFinite(current) && !Object.is(current, -0))
+                return current;
+            const encoded = Number.isNaN(current)
+                ? 'NaN'
+                : current === Infinity
+                    ? 'Infinity'
+                    : current === -Infinity
+                        ? '-Infinity'
+                        : '-0';
+            return { [tag]: 'number', value: encoded };
+        }
+        if (typeof current === 'bigint')
+            return { [tag]: 'bigint', value: current.toString() };
+        if (typeof current === 'undefined')
+            return { [tag]: 'undefined' };
+        if (typeof current !== 'object')
+            return { [tag]: 'opaque', kind: typeof current };
+        if (depth >= 64)
+            return { [tag]: 'opaque', kind: 'max-depth' };
+        if (ancestors.has(current))
+            return { [tag]: 'opaque', kind: 'cycle' };
+        ancestors.add(current);
+        try {
+            if (current instanceof ArrayBuffer) {
+                return {
+                    [tag]: 'binary',
+                    kind: 'ArrayBuffer',
+                    encoding: 'base64',
+                    value: Buffer.from(current).toString('base64'),
+                };
+            }
+            if (ArrayBuffer.isView(current)) {
+                return {
+                    [tag]: 'binary',
+                    kind: current.constructor?.name ?? 'ArrayBufferView',
+                    encoding: 'base64',
+                    value: Buffer.from(current.buffer, current.byteOffset, current.byteLength).toString('base64'),
+                };
+            }
+            if (current instanceof Date) {
+                const timestamp = current.getTime();
+                return {
+                    [tag]: 'date',
+                    value: Number.isNaN(timestamp) ? 'invalid' : current.toISOString(),
+                };
+            }
+            if (current instanceof Map) {
+                const entries = [...current.entries()].map(([key, entry]) => [
+                    visit(key, depth + 1),
+                    visit(entry, depth + 1),
+                ]);
+                return { [tag]: 'map', entries };
+            }
+            if (current instanceof Set) {
+                return { [tag]: 'set', entries: [...current].map((entry) => visit(entry, depth + 1)) };
+            }
+            if (Array.isArray(current)) {
+                return Array.from({ length: current.length }, (_, index) => index in current ? visit(current[index], depth + 1) : { [tag]: 'array-hole' });
+            }
+            if (isPlainObject(current)) {
+                const entries = Object.keys(current).map((key) => {
+                    try {
+                        return [key, visit(current[key], depth + 1)];
+                    }
+                    catch {
+                        return [key, { [tag]: 'opaque', kind: 'unreadable-property' }];
+                    }
+                });
+                if (Object.hasOwn(current, tag))
+                    return { [tag]: 'object', entries };
+                return Object.fromEntries(entries);
+            }
+            const toJSON = current.toJSON;
+            if (typeof toJSON === 'function') {
+                try {
+                    return visit(toJSON.call(current), depth + 1);
+                }
+                catch {
+                    return { [tag]: 'opaque', kind: 'toJSON-failed' };
+                }
+            }
+            return { [tag]: 'opaque', kind: current.constructor?.name ?? 'non-plain-object' };
+        }
+        finally {
+            ancestors.delete(current);
+        }
     };
+    return visit(value, 0);
 }
 function toolShapeForDiagnostics(tool) {
     return {
@@ -462,42 +320,6 @@ function stripJsonSchemaRuntimeFields(value) {
     }
     return out;
 }
-function messageShapeForHash(message) {
-    const raw = message;
-    return {
-        role: typeof raw.role === 'string' ? raw.role : 'unknown',
-        content: contentShapeForHash(raw.content),
-    };
-}
-function contentShapeForHash(content) {
-    if (typeof content === 'string') {
-        return { type: 'text', chars: content.length };
-    }
-    if (Array.isArray(content)) {
-        return content.map((part) => {
-            if (!isObjectLike(part))
-                return { type: typeof part };
-            const type = typeof part.type === 'string' ? part.type : 'unknown';
-            return {
-                type,
-                ...(typeof part.toolName === 'string' ? { toolName: part.toolName } : {}),
-                ...(typeof part.toolCallId === 'string' ? { toolCallId: part.toolCallId } : {}),
-                ...(typeof part.text === 'string' ? { chars: part.text.length } : {}),
-                ...('output' in part ? { output: payloadShapeForHash(part.output) } : {}),
-            };
-        });
-    }
-    return { type: typeof content };
-}
-function payloadShapeForHash(value) {
-    const serialized = stableStringify(value);
-    return {
-        type: value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value,
-        chars: serialized.length,
-        bytes: Buffer.byteLength(serialized, 'utf8'),
-        hash: stableHash(value),
-    };
-}
 function canonicalize(value, parentKey) {
     if (value === null)
         return null;