maka-agent 0.2.0-dev.24.20260907 → 0.2.0-dev.26.20260909

package/node_modules/@maka/runtime/dist/ledger-tool-result-archive-reader.js

@@ -18,9 +18,11 @@
  */
 import { createHash } from 'node:crypto';
 import { decodeDurableToolResultProjection } from '@maka/core/durable-tool-result-projection';
+import { durableToolResultProjectionDigest, } from '@maka/core/model-projection-transition';
 import { decodeLedgerTransition, reduceEffectiveModelProjections, } from './model-projection-transition-ledger.js';
 import { isArchivedToolResultPlaceholder, } from './tool-result-archive.js';
 import { serializeToolResultProjectionV1 } from './tool-result-archive-encoding.js';
+import { TOOL_RESULT_ARCHIVE_EVIDENCE_MAX_BYTES, TOOL_RESULT_ARCHIVE_EVIDENCE_MAX_TRANSITIONS, } from '@maka/core/tool-result-archive-evidence';
 /**
  * Read-only v1 reconstruction. It never calls a live tool projector, reads an
  * Artifact, changes history, or authorizes access from a hash alone.
@@ -80,7 +82,13 @@ export function createLedgerToolResultArchiveReader(evidence) {
                 const replacement = transition.replacement;
                 const placeholder = replacement.kind === 'json' ? replacement.value : undefined;
                 if (isArchivedToolResultPlaceholder(placeholder) &&
-                    placeholder.artifactId === request.artifactId) {
+                    ((placeholder.rewriteVersion === 1 &&
+                        request.rewriteVersion === 1 &&
+                        placeholder.artifactId === request.artifactId) ||
+                        (placeholder.rewriteVersion === 2 &&
+                            request.rewriteVersion === 2 &&
+                            placeholder.sourceProjectionDigest === request.sourceProjectionDigest &&
+                            placeholder.previousTransitionId === request.previousTransitionId))) {
                     if (placeholder.runtimeEventId !== request.runtimeEventId ||
                         placeholder.toolCallId !== request.toolCallId ||
                         placeholder.toolName !== request.toolName ||
@@ -88,6 +96,10 @@ export function createLedgerToolResultArchiveReader(evidence) {
                         placeholder.originalBytes !== request.originalBytes ||
                         placeholder.rewriteVersion !== request.rewriteVersion)
                         return { ok: false, reason: 'source_mismatch' };
+                    if (placeholder.rewriteVersion === 2 &&
+                        (placeholder.sourceProjectionDigest !== transition.sourceProjectionDigest ||
+                            placeholder.previousTransitionId !== transition.previousTransitionId))
+                        return { ok: false, reason: 'corrupt' };
                     const serializedResult = serializeToolResultProjectionV1(source);
                     if (Buffer.byteLength(serializedResult, 'utf8') !== request.originalBytes)
                         return { ok: false, reason: 'size_mismatch' };
@@ -104,3 +116,59 @@ export function createLedgerToolResultArchiveReader(evidence) {
         }
     };
 }
+export function createLedgerArchiveResourceReader(evidence) {
+    const reader = createLedgerToolResultArchiveReader(evidence);
+    return (input) => reader({
+        ...input,
+        kind: 'maka.archived_tool_result',
+        rewriteVersion: 2,
+        originalEstimatedTokens: 1,
+        reason: 'stale_tool_result_pruned_before_compact',
+    });
+}
+/** Verify reconstructibility before committing a replacement; does not write any payload. */
+export function createLedgerArchivePreparer(evidence) {
+    return async (input) => {
+        const request = { ...input };
+        const loaded = await evidence.read({
+            sessionId: request.sessionId,
+            runtimeEventId: request.runtimeEventId,
+        });
+        if (!loaded.ok ||
+            loaded.transitions.length >= TOOL_RESULT_ARCHIVE_EVIDENCE_MAX_TRANSITIONS ||
+            loaded.storedBytes === undefined ||
+            loaded.storedBytes > TOOL_RESULT_ARCHIVE_EVIDENCE_MAX_BYTES - 64 * 1024)
+            return;
+        const content = loaded.event.content;
+        if (loaded.event.sessionId !== request.sessionId ||
+            loaded.event.id !== request.runtimeEventId ||
+            content?.kind !== 'function_response' ||
+            content.providerExecuted ||
+            !content.modelProjection ||
+            content.id !== request.toolCallId ||
+            content.name !== request.toolName)
+            return;
+        const transitions = [];
+        for (const event of loaded.transitions) {
+            const decoded = decodeLedgerTransition(event, request.sessionId);
+            if (!decoded || decoded.target.runtimeEventId !== request.runtimeEventId)
+                return;
+            transitions.push(decoded);
+        }
+        const reduced = reduceEffectiveModelProjections([loaded.event], transitions);
+        const previous = reduced.applied.at(-1);
+        if (previous?.transitionId !== request.previousTransitionId)
+            return;
+        const source = previous?.replacement ?? content.modelProjection;
+        if (source.kind === 'json' && isArchivedToolResultPlaceholder(source.value))
+            return;
+        if (durableToolResultProjectionDigest(source) !== request.sourceProjectionDigest)
+            return;
+        const body = serializeToolResultProjectionV1(source);
+        if (body !== request.serializedResult ||
+            Buffer.byteLength(body) !== request.originalBytes ||
+            createHash('sha256').update(body).digest('hex') !== request.bodySha256)
+            return;
+        return { ledger: true };
+    };
+}

package/node_modules/@maka/runtime/dist/mcp-tools.js

@@ -18,6 +18,7 @@
  */
 import { createHash } from 'node:crypto';
 import { jsonSchema } from 'ai';
+import { REQUEST_COMPOSITION_MAX_TOOL_DESCRIPTION_LENGTH } from '@maka/core/run-composition';
 import { truncateUtf16Safe } from '@maka/core/text-sanitize';
 const MAX_PROVIDER_TOOL_NAME = 64;
 const HASH_CHARS = 10;
@@ -49,8 +50,7 @@ export function buildMcpToolsWithIdentities(provider, options = {}) {
             toolName: descriptor.name,
             tool: {
                 name,
-                description: descriptor.description?.trim() ||
-                    `MCP tool ${descriptor.name} provided by ${descriptor.serverId}`,
+                description: mcpToolDescription(descriptor),
                 displayName: descriptor.annotations?.title?.trim() || descriptor.name,
                 activityKind: options.activityKindForDescriptor?.(descriptor) ?? 'tool',
                 // MCP annotations are advisory provider claims, not a security boundary.
@@ -129,6 +129,11 @@ export function buildMcpToolsWithIdentities(provider, options = {}) {
         };
     });
 }
+function mcpToolDescription(descriptor) {
+    const description = descriptor.description?.trim() ||
+        `MCP tool ${descriptor.name} provided by ${descriptor.serverId}`;
+    return description.slice(0, REQUEST_COMPOSITION_MAX_TOOL_DESCRIPTION_LENGTH);
+}
 export function mcpProxyToolName(serverId, toolName) {
     const raw = `mcp__${sanitizeNamePart(serverId)}__${sanitizeNamePart(toolName)}`;
     if (raw.length <= MAX_PROVIDER_TOOL_NAME)

package/node_modules/@maka/runtime/dist/model-fetcher.js

@@ -257,6 +257,12 @@ function normalizeConnectionEffectModels(models) {
         });
     }
 }
+export class GitHubCopilotModelPolicyError extends Error {
+    constructor() {
+        super('GitHub Copilot model policy is not enabled');
+        this.name = 'GitHubCopilotModelPolicyError';
+    }
+}
 export async function fetchGitHubCopilotModels(baseUrl, accessToken, fetchFn) {
     const response = await fetchForConnectionEffect(fetchFn, `${stripTrailing(baseUrl)}/models`, {
         headers: {
@@ -272,7 +278,12 @@ export async function fetchGitHubCopilotModels(baseUrl, accessToken, fetchFn) {
         throw new ConnectionEffectHttpError(response.status);
     }
     const payload = await readProviderJson(response);
-    return providerObjectArray(payload.data, 'GitHub Copilot models', true).flatMap(toGitHubCopilotModelInfo);
+    const rawModels = providerObjectArray(payload.data, 'GitHub Copilot models', true);
+    const models = rawModels.flatMap(toGitHubCopilotModelInfo);
+    if (models.length === 0 && rawModels.some(isGitHubCopilotModelBlockedByPolicy)) {
+        throw new GitHubCopilotModelPolicyError();
+    }
+    return models;
 }
 /**
  * Discovery error carrying the HTTP status, so callers (syncOpenAiCodexConnection)
@@ -347,7 +358,12 @@ function toGitHubCopilotModelInfo(model) {
     if (typeof model.id !== 'string' ||
         !model.id ||
         model.model_picker_enabled !== true ||
-        model.policy?.state === 'disabled' ||
+        // GitHub historically returned enabled/disabled/unconfigured policy gates.
+        // A policy-free model needs no acknowledgement; when the gate is present,
+        // Maka can use the model only after another client has enabled it. Maka has
+        // no policy-acceptance flow, so fail closed over unconfigured and unknown
+        // states instead of advertising a model that inference will reject.
+        !isGitHubCopilotModelPolicyEnabled(model.policy) ||
         model.capabilities?.supports?.tool_calls !== true)
         return [];
     assertOptionalArray(model.supported_endpoints, 'model supported_endpoints');
@@ -385,6 +401,28 @@ function toGitHubCopilotModelInfo(model) {
         },
     ];
 }
+function isGitHubCopilotModelPolicyEnabled(policy) {
+    if (policy === undefined)
+        return true;
+    if (!policy || typeof policy !== 'object' || Array.isArray(policy))
+        return false;
+    return policy.state === 'enabled';
+}
+function isGitHubCopilotModelBlockedByPolicy(model) {
+    if (typeof model.id !== 'string' ||
+        !model.id ||
+        model.model_picker_enabled !== true ||
+        model.capabilities?.supports?.tool_calls !== true ||
+        !Array.isArray(model.supported_endpoints) ||
+        !model.supported_endpoints.some((endpoint) => ['/v1/messages', '/responses', '/chat/completions'].includes(endpoint))) {
+        return false;
+    }
+    if (!model.policy || typeof model.policy !== 'object' || Array.isArray(model.policy)) {
+        return false;
+    }
+    const state = model.policy.state;
+    return state === 'disabled' || state === 'unconfigured';
+}
 async function fetchCohereModels(baseUrl, apiKey, fetchFn) {
     const root = stripTrailing(baseUrl).replace(/\/v2$/, '');
     const models = [];
@@ -655,6 +693,8 @@ function nextProviderPageToken(value) {
     return value;
 }
 function classifyDiscoveryError(error) {
+    if (error instanceof GitHubCopilotModelPolicyError)
+        return { kind: 'auth' };
     if (error instanceof ConnectionEffectFetchError)
         return { kind: error.kind };
     if (error instanceof ConnectionEffectHttpError) {

package/node_modules/@maka/runtime/dist/model-history.js

@@ -278,56 +278,6 @@ export function buildRuntimeEventReplayTimeline(items) {
 function replayToolIdentity(invocationId, toolCallId) {
     return JSON.stringify([invocationId, toolCallId]);
 }
-// ============================================================================
-// Projection
-// ============================================================================
-/**
- * Build the model-visible history from a RuntimeEvent stream.
- *
- * Events SHOULD be supplied in causal order; the projection preserves
- * input order. Partial events are always excluded — callers MUST NOT
- * replay transient streaming chunks into the next model call.
- *
- * The default options match the durable-history policy: user/model text
- * and tool calls/responses are kept; thinking, system notes, token usage,
- * permission acks, and diagnostics are dropped.
- */
-export function buildModelHistoryFromRuntimeEvents(events, options = {}) {
-    const includeToolEvents = options.includeToolEvents ?? true;
-    const includeSystemEvents = options.includeSystemEvents ?? false;
-    const includeThinking = options.includeThinking ?? false;
-    const out = [];
-    for (const event of events) {
-        // 1. Never replay transient streaming chunks.
-        if (isPartialRuntimeEvent(event))
-            continue;
-        // 2. Only model-visible content kinds (text/thinking/function_*).
-        if (!runtimeEventHasModelVisibleContent(event))
-            continue;
-        const content = event.content;
-        if (!content)
-            continue;
-        // 3. System-role events are UI notes by default; opt in for
-        //    model-injected system instructions.
-        if (event.role === 'system' && !includeSystemEvents)
-            continue;
-        // 4. Thinking replay is provider-specific; opt in.
-        if (content.kind === 'thinking' && !includeThinking)
-            continue;
-        // 5. Tool function_call / function_response; opt out for text-only.
-        if (!includeToolEvents &&
-            (content.kind === 'function_call' || content.kind === 'function_response')) {
-            continue;
-        }
-        out.push({
-            role: event.role,
-            content,
-            ts: event.ts,
-            eventId: event.id,
-        });
-    }
-    return out;
-}
 /**
  * Collect the turn ids that contain tool activity (function_call /
  * function_response) from a RuntimeEvent ledger. Pass the result as
@@ -645,46 +595,6 @@ export function buildRuntimeEventModelReplayPlan(events, options = {}) {
             semanticKinds.includes('tool_result'),
     };
 }
-/**
- * Convert projected RuntimeEvent history into the current AI SDK text-only
- * message shape. Tool/function and thinking entries are intentionally skipped.
- */
-export function buildTextModelMessagesFromRuntimeEvents(events, options = {}) {
-    const history = buildModelHistoryFromRuntimeEvents(events, {
-        includeToolEvents: false,
-        includeSystemEvents: options.includeSystemEvents ?? false,
-        includeThinking: false,
-    });
-    const out = [];
-    for (const entry of history) {
-        if (entry.content.kind !== 'text')
-            continue;
-        if (entry.role === 'tool')
-            continue;
-        if (entry.role === 'system' && !options.includeSystemEvents)
-            continue;
-        const role = entry.role === 'model'
-            ? 'assistant'
-            : entry.role === 'user'
-                ? 'user'
-                : entry.role === 'system'
-                    ? 'system'
-                    : undefined;
-        if (!role)
-            continue;
-        const steering = entry.content.steering === true && role === 'user';
-        out.push({
-            role,
-            content: steering
-                ? buildSteeringEnvelope(formatTextWithInlineRefs(entry.content))
-                : formatTextWithInlineRefs(entry.content),
-            // Keep the structured identity even in the text-only shape: dedupe
-            // against the live injection set works by ledger event id.
-            ...(steering ? { providerOptions: steeringProviderOptions(entry.eventId) } : {}),
-        });
-    }
-    return out;
-}
 function modelTextRole(role) {
     switch (role) {
         case 'user':
@@ -770,28 +680,6 @@ export function steeringMessagesMissingFromBase(injected, baseMessages) {
         return eventId === undefined || !present.has(eventId);
     });
 }
-/**
- * The messages with THIS TURN'S injected steering removed (transport-retry
- * base). Only the injected set may be stripped: the retry attempt's own
- * request projection re-appends exactly that accumulator, while a historical,
- * ledger-replayed steering message (same marker, different event id) is part
- * of the base that nothing re-appends — stripping it would erase it from
- * every post-retry request.
- */
-export function stripSteeringMessages(messages, injected) {
-    const ids = new Set();
-    for (const message of injected) {
-        const eventId = steeringEventIdOf(message);
-        if (eventId !== undefined)
-            ids.add(eventId);
-    }
-    if (ids.size === 0)
-        return [...messages];
-    return messages.filter((message) => {
-        const eventId = steeringEventIdOf(message);
-        return eventId === undefined || !ids.has(eventId);
-    });
-}
 /**
  * Fold a user turn's inline references into its model-facing text. Attachments
  * render as a name/type block with exact Read instructions when the reference

package/node_modules/@maka/runtime/dist/plugin-runtime.js

@@ -269,10 +269,9 @@ function registerPluginEffect(ctx, label, register) {
 }
 export function registerPluginContribution(ctx, label, register) {
     if (ctx.makaTransaction) {
-        ctx.makaTransaction.stage(label, register, ctx);
-        return;
+        return ctx.makaTransaction.stage(label, register, ctx);
     }
-    registerPluginEffect(ctx, label, register);
+    return registerPluginEffect(ctx, label, register);
 }
 export class MakaPluginTransactionBuffer {
     context;
@@ -283,13 +282,22 @@ export class MakaPluginTransactionBuffer {
     }
     stage(label, register, owner = this.context) {
         if (this.#state === 'committed') {
-            registerPluginEffect(owner, label, register);
-            return;
+            return registerPluginEffect(owner, label, register);
         }
         if (this.#state === 'rolled_back') {
             throw new MakaPluginRuntimeError('activation_failed', `Cannot stage contribution after transaction is ${this.#state}`);
         }
-        this.#registrations.push({ label, register, owner });
+        const item = {
+            label,
+            register,
+            owner,
+            cancelled: false,
+        };
+        this.#registrations.push(item);
+        return async () => {
+            item.cancelled = true;
+            await item.release?.();
+        };
     }
     async commit() {
         if (this.#state === 'committed')
@@ -300,7 +308,10 @@ export class MakaPluginTransactionBuffer {
         const registered = [];
         try {
             for (const item of this.#registrations) {
-                registered.push(registerPluginEffect(item.owner, item.label, item.register));
+                if (item.cancelled)
+                    continue;
+                item.release = registerPluginEffect(item.owner, item.label, item.register);
+                registered.push(item.release);
             }
             this.#state = 'committed';
             this.#registrations.length = 0;
@@ -333,10 +344,9 @@ export class MakaPluginTransactionBuffer {
 export function fiberStateName(state) {
     return ['pending', 'loading', 'active', 'failed', 'disposed', 'unloading'][state];
 }
-export function isCanonicalPluginId(value) {
+export function isCanonicalExtensionId(value) {
     return typeof value === 'string' && value.length <= 128 && ID_PATTERN.test(value);
 }
-export const isCanonicalExtensionId = isCanonicalPluginId;
 function cloneCompositionEntry(entry) {
     return {
         ...entry,
@@ -384,7 +394,7 @@ export function isCanonicalExtensionScopeId(value) {
     return (typeof value === 'string' && value.length <= 128 && /^[A-Za-z0-9][A-Za-z0-9._:-]*$/u.test(value));
 }
 function validatePluginId(value, label) {
-    if (!isCanonicalPluginId(value)) {
+    if (!isCanonicalExtensionId(value)) {
         throw new MakaPluginRuntimeError('invalid_entry', `Invalid ${label}`);
     }
 }

package/node_modules/@maka/runtime/dist/plugin-tool-service.js

@@ -0,0 +1,205 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { REQUEST_COMPOSITION_MAX_TOOL_DESCRIPTION_LENGTH } from '@maka/core/run-composition';
+import { Service } from './plugin-kernel.js';
+import { MakaPluginRuntimeError, pluginIdentity, registerPluginContribution, } from './plugin-runtime.js';
+import { bindToolActivationIdentity } from './tool-activation-identity.js';
+import { TOOL_SEARCH_NAME, TOOL_SEARCH_PROVIDER_NAME } from './tool-availability.js';
+/**
+ * Context-scoped Tool contribution registry for trusted Host plugins.
+ *
+ * Registration is staged by the Plugin Platform transaction and owned by the
+ * registering Fiber. Profile registrations are inherited by Session roots;
+ * an exact Session registration shadows the Profile registration. Core tools
+ * remain Host-owned and cannot be shadowed.
+ */
+export class PluginToolService extends Service {
+    layers = new Map();
+    onChanged;
+    constructor(ctx, options = {}) {
+        super(ctx, 'tools');
+        this.onChanged = options.onChanged;
+    }
+    register(definition) {
+        const identity = pluginIdentity(this.ctx);
+        if (identity.scopeId === 'desktop-ui') {
+            throw new MakaPluginRuntimeError('activation_failed', 'desktop-ui plugins cannot register Host tools');
+        }
+        validateTool(definition);
+        return registerPluginContribution(this.ctx, `tools.register(${JSON.stringify(definition.name)})`, () => this.publish(identity, definition));
+    }
+    resolve(sessionId, coreTools) {
+        const contributions = this.resolveContributions(sessionId, coreTools);
+        return Object.freeze({
+            tools: Object.freeze([...coreTools, ...contributions.tools]),
+        });
+    }
+    /** Resolve only Plugin-owned additions after validating them against the Host binding. */
+    resolveContributions(sessionId, coreTools) {
+        if (!sessionId || /[\r\n\0]/u.test(sessionId))
+            throw new Error('Invalid Tool Session scope');
+        const visible = new Map();
+        for (const entry of this.layers.get('profile')?.values() ?? []) {
+            visible.set(entry.definition.name, entry);
+        }
+        const sessionRoot = `session:${sessionId}`;
+        for (const entry of this.layers.get(sessionRoot)?.values() ?? []) {
+            visible.set(entry.definition.name, entry);
+        }
+        const coreNames = new Set(coreTools.map(({ name }) => name));
+        for (const name of visible.keys()) {
+            if (coreNames.has(name)) {
+                throw new MakaPluginRuntimeError('activation_failed', `Plugin Tool ${JSON.stringify(name)} conflicts with a Host-owned Tool`);
+            }
+        }
+        const entries = [...visible.values()].sort(compareRegistration);
+        return Object.freeze({
+            tools: Object.freeze(entries.map(({ exposed }) => exposed)),
+        });
+    }
+    inspect(rootId) {
+        const layers = rootId
+            ? [[rootId, this.layers.get(rootId)]]
+            : [...this.layers.entries()];
+        return Object.freeze(layers
+            .flatMap(([, layer]) => [...(layer?.values() ?? [])])
+            .sort(compareRegistration)
+            .map((entry) => Object.freeze({
+            entryId: entry.entryId,
+            scopeId: entry.scopeId,
+            extensionId: entry.extensionId,
+            generation: entry.generation,
+            toolName: entry.definition.name,
+            activeCalls: entry.activeCalls,
+            retired: entry.retired,
+        })));
+    }
+    publish(identity, definition) {
+        const rootId = identity.scopeId;
+        let layer = this.layers.get(rootId);
+        if (!layer) {
+            layer = new Map();
+            this.layers.set(rootId, layer);
+        }
+        const existing = layer.get(definition.name);
+        if (existing && existing.entryId !== identity.entryId) {
+            throw new MakaPluginRuntimeError('activation_failed', `Plugin Tool ${JSON.stringify(definition.name)} is already registered by ${existing.entryId}`);
+        }
+        let entry;
+        const exposed = bindToolActivationIdentity({
+            ...definition,
+            impl: async (args, context) => {
+                if (entry.retired) {
+                    throw new Error(`Plugin Tool ${JSON.stringify(definition.name)} is no longer active`);
+                }
+                entry.activeCalls += 1;
+                try {
+                    return await definition.impl(args, context);
+                }
+                finally {
+                    entry.activeCalls -= 1;
+                    if (entry.activeCalls === 0) {
+                        for (const resolve of entry.drainWaiters)
+                            resolve();
+                        entry.drainWaiters.clear();
+                    }
+                }
+            },
+        }, {
+            kind: 'plugin',
+            scopeId: identity.scopeId,
+            entryId: identity.entryId,
+            extensionId: identity.extensionId,
+            generation: identity.generation,
+            toolName: definition.name,
+        });
+        entry = {
+            ...identity,
+            definition,
+            exposed,
+            token: Symbol(definition.name),
+            activeCalls: 0,
+            retired: false,
+            drainWaiters: new Set(),
+        };
+        layer.set(definition.name, entry);
+        try {
+            this.notifyChanged(rootId);
+        }
+        catch (error) {
+            if (existing)
+                layer.set(definition.name, existing);
+            else
+                layer.delete(definition.name);
+            if (layer.size === 0)
+                this.layers.delete(rootId);
+            throw error;
+        }
+        return async () => {
+            entry.retired = true;
+            const currentLayer = this.layers.get(rootId);
+            if (currentLayer?.get(definition.name)?.token === entry.token) {
+                if (existing && !existing.retired)
+                    currentLayer.set(definition.name, existing);
+                else
+                    currentLayer.delete(definition.name);
+                if (currentLayer.size === 0)
+                    this.layers.delete(rootId);
+                this.notifyChanged(rootId);
+            }
+            if (entry.activeCalls > 0) {
+                await new Promise((resolve) => entry.drainWaiters.add(resolve));
+            }
+        };
+    }
+    notifyChanged(rootId) {
+        this.ctx.emit('tools/change');
+        this.onChanged?.(rootId);
+    }
+}
+function validateTool(tool) {
+    if (!tool || typeof tool !== 'object')
+        throw new TypeError('Tool definition is required');
+    if (typeof tool.name !== 'string' ||
+        tool.name.length === 0 ||
+        tool.name.length > 128 ||
+        /[\r\n\0]/u.test(tool.name)) {
+        throw new TypeError('Tool requires a valid name');
+    }
+    if (typeof tool.description !== 'string' ||
+        tool.description.length === 0 ||
+        tool.description.length > REQUEST_COMPOSITION_MAX_TOOL_DESCRIPTION_LENGTH ||
+        typeof tool.impl !== 'function') {
+        throw new TypeError(`Tool ${JSON.stringify(tool.name)} requires a description of at most ${REQUEST_COMPOSITION_MAX_TOOL_DESCRIPTION_LENGTH} characters and an implementation`);
+    }
+    if (tool.parameters === undefined) {
+        throw new TypeError(`Tool ${JSON.stringify(tool.name)} requires an input schema`);
+    }
+    if (tool.providerTool) {
+        throw new TypeError(`Plugin Tool ${JSON.stringify(tool.name)} cannot claim a provider protocol`);
+    }
+    if (tool.name === TOOL_SEARCH_NAME || tool.name === TOOL_SEARCH_PROVIDER_NAME) {
+        throw new TypeError(`Plugin Tool name ${JSON.stringify(tool.name)} is reserved by Runtime`);
+    }
+}
+function compareRegistration(left, right) {
+    return (left.definition.name.localeCompare(right.definition.name) ||
+        left.scopeId.localeCompare(right.scopeId) ||
+        left.entryId.localeCompare(right.entryId));
+}

package/node_modules/@maka/runtime/dist/provider-request-telemetry.js

@@ -199,14 +199,18 @@ export class ProviderRequestTracker {
      * that call, not new calls, so they share this id.
      */
     logicalCallIdByStep = new Map();
+    requestCompositionIdByStep = new Map();
     constructor(input) {
         this.input = input;
     }
     get traceId() {
         return this.input.traceId;
     }
-    setStep(step) {
+    setStep(step, requestCompositionId) {
         this.step = step;
+        if (requestCompositionId !== undefined) {
+            this.requestCompositionIdByStep.set(step, requestCompositionId);
+        }
     }
     async trackStream(input) {
         throwIfAbortedBeforeDispatch(input.abortSignal);
@@ -356,6 +360,9 @@ export class ProviderRequestTracker {
                         ? { connectionSlug: accounting.connectionSlug }
                         : {}),
                     step: Math.max(0, step),
+                    ...(this.requestCompositionIdByStep.get(step)
+                        ? { requestCompositionId: this.requestCompositionIdByStep.get(step) }
+                        : {}),
                     attempt: Math.max(0, attempt - 1),
                     callKind: accounting.callKind,
                     ...((input.historyCompactRoute ?? accounting.historyCompactRoute) !== undefined

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

@@ -152,6 +152,29 @@ 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));
 }