veryfront 0.1.755 → 0.1.756

package/esm/src/agent/runtime/index.js

@@ -20,15 +20,17 @@ import { addSpanEvent, setSpanAttributes, withSpan, } from "../../observability/
 import { convertToTextGenerationRuntimeMessages } from "./text-generation-runtime-message-converter.js";
 import { convertToolsToRuntimeTools } from "./model-tool-converter.js";
 import { resolveProviderOptionsWithDefaults } from "./default-provider-options.js";
-import { getRuntimeRemoteToolSources, } from "./mcp-server-tool-sources.js";
+import { getRuntimeRemoteToolSources } from "./mcp-server-tool-sources.js";
 import { createStreamState, processStream, } from "./chat-stream-handler.js";
 import { repairToolCall } from "./repair-tool-call.js";
-import { stripLeadingEmptyObjectPlaceholder } from "../streaming/data-stream.js";
 import { MiddlewareChain } from "../middleware/chain.js";
 import { AGENT_DEFAULTS } from "./defaults.js";
 import { tryGetCacheKeyContext } from "../../cache/cache-key-builder.js";
 import { isLocalModelRuntime } from "../../provider/runtime-inspection.js";
 import { generateText, streamText } from "../../runtime/runtime-bridge.js";
+import { captureStreamedToolCallInput, collectFinalStreamToolResults, collectGeneratedToolResults, createToolErrorMessage, createToolResultMessage, getProviderExecutedToolNames, getToolResultError, isRecoverablePlaceholderToolCall, isStreamedToolCallIncomplete, materializeStreamedToolCall, shouldContinueAfterStreamStep, } from "./tool-result-continuation.js";
+import { enforceSkillPolicy, extractSkillPolicy, hydrateActiveSkillStateFromMessages, LOAD_SKILL_TOOL_ID, } from "./skill-policy-enforcement.js";
+import { getRuntimeAllowedRemoteTools, getRuntimeForwardedIntegrationToolDefs, getRuntimeProviderTools, } from "./runtime-tool-config.js";
 // Re-export from submodules
 export { closeSSEStream, generateMessageId, sendSSE } from "./sse-utils.js";
 export { RunAlreadyExistsError, RunCancelledError, RunNotActiveError, RunResumeSessionManager, WaitConflictError, WaitNotPendingError, } from "./resume-session.js";
@@ -37,357 +39,30 @@ export { getProviderToolProfile, sanitizeProviderToolSchema, selectProviderCompa
 export { accumulateUsage, getMaxSteps, normalizeInput } from "./input-utils.js";
 export { createStreamState, processStream } from "./chat-stream-handler.js";
 export { DEFAULT_MAX_STEPS, DEFAULT_MAX_TOKENS, DEFAULT_TEMPERATURE, MAX_STREAM_BUFFER_SIZE, } from "./constants.js";
+export { captureStreamedToolCallInput, collectFinalStreamToolResults, collectGeneratedToolResults, collectPersistedToolResults, isRecoverablePlaceholderToolCall, isStreamedToolCallIncomplete, materializeStreamedToolCall, shouldContinueAfterStreamStep, } from "./tool-result-continuation.js";
+export { enforceSkillPolicy, extractSkillPolicy, } from "./skill-policy-enforcement.js";
 import { DEFAULT_MAX_TOKENS, DEFAULT_TEMPERATURE, getModelMaxOutputTokens } from "./constants.js";
 import { closeSSEStream, generateMessageId, sendSSE } from "./sse-utils.js";
-import { executeConfiguredTool, getAvailableTools, isDynamicTool, parseToolArgs, } from "./tool-helpers.js";
+import { executeConfiguredTool, getAvailableTools, isDynamicTool } from "./tool-helpers.js";
 import { accumulateUsage, getMaxSteps, normalizeInput } from "./input-utils.js";
-import { filterToolsForSkill, isToolAllowedBySkill, validateAllowedToolPatterns, } from "../../skill/allowed-tools.js";
+import { filterToolsForSkill } from "../../skill/allowed-tools.js";
 import { resolveConfiguredAgentModel, resolveRuntimeModel } from "./model-resolution.js";
 import { stringifyToolError, throwIfAborted } from "./error-utils.js";
+import { supportsTemperatureParameter } from "./model-capabilities.js";
 import { applySkillDelegationOverridesToToolInput, extractSkillDelegationOverrides, } from "./skill-delegation-overrides.js";
 const logger = serverLogger.component("agent");
-const LOAD_SKILL_TOOL_ID = "load_skill";
 function isAbortError(error, abortSignal) {
     if (abortSignal?.aborted && error === abortSignal.reason) {
         return true;
     }
     return error instanceof DOMException && error.name === "AbortError";
 }
-function getToolResultError(result) {
-    if (!result || typeof result !== "object" || !("error" in result)) {
-        return undefined;
-    }
-    return stringifyToolError(result.error);
-}
-function getSkillActivationRequiredError(toolName) {
-    return `Tool "${toolName}" cannot run before load_skill succeeds in the same step. ` +
-        `Call "${LOAD_SKILL_TOOL_ID}" first to establish the active skill context.`;
-}
 function warnLocalToolSkipping(agentId, modelId) {
     logger.warn(`Agent "${agentId}" has tools configured but is using local model "${modelId}". ` +
         "Local models don't support tool calling — tools will be skipped. " +
         "Set VERYFRONT_API_TOKEN and VERYFRONT_PROJECT_SLUG, or configure " +
         "OPENAI_API_KEY, ANTHROPIC_API_KEY, or GOOGLE_API_KEY for full tool support.");
 }
-function createToolResultMessage(toolCallId, toolName, result, providerExecuted = false) {
-    return {
-        id: `tool_${toolCallId}`,
-        role: "tool",
-        parts: [
-            {
-                type: "tool-result",
-                toolCallId,
-                toolName,
-                result,
-                ...(providerExecuted ? { providerExecuted: true } : {}),
-            },
-        ],
-        timestamp: Date.now(),
-    };
-}
-function createToolErrorMessage(toolCallId, toolName, error) {
-    return {
-        id: `tool_error_${toolCallId}`,
-        role: "tool",
-        parts: [
-            {
-                type: "tool-result",
-                toolCallId,
-                toolName,
-                result: { error },
-            },
-        ],
-        timestamp: Date.now(),
-    };
-}
-function getProviderExecutedToolNames(runtimeTools) {
-    if (!runtimeTools) {
-        return [];
-    }
-    return Object.entries(runtimeTools).flatMap(([toolName, definition]) => {
-        if (definition &&
-            typeof definition === "object" &&
-            "type" in definition &&
-            definition.type === "provider") {
-            return [toolName];
-        }
-        return [];
-    });
-}
-export function collectFinalStreamToolResults(state) {
-    const finalToolResults = new Map();
-    for (const toolResult of state.toolResults) {
-        if (toolResult.preliminary === true) {
-            continue;
-        }
-        finalToolResults.set(toolResult.toolCallId, toolResult);
-    }
-    return finalToolResults;
-}
-export function collectPersistedToolResults(messages) {
-    const persistedToolResults = new Map();
-    for (const message of messages) {
-        if (message.role !== "tool") {
-            continue;
-        }
-        for (const part of message.parts) {
-            if (!isToolResultPart(part)) {
-                continue;
-            }
-            persistedToolResults.set(part.toolCallId, part);
-        }
-    }
-    return persistedToolResults;
-}
-export function collectGeneratedToolResults(toolResults) {
-    const generatedToolResults = new Map();
-    for (const toolResult of toolResults ?? []) {
-        generatedToolResults.set(toolResult.toolCallId, toolResult);
-    }
-    return generatedToolResults;
-}
-export function shouldContinueAfterStreamStep(state) {
-    if (!state.toolCalls.size) {
-        return false;
-    }
-    const streamedToolCalls = Array.from(state.toolCalls.values());
-    const hasIncompleteToolCall = streamedToolCalls.some(isStreamedToolCallIncomplete);
-    const hasFinalizedClientToolCall = streamedToolCalls.some((toolCall) => toolCall.inputAvailable === true && toolCall.providerExecuted !== true);
-    const hasProviderExecutedToolCall = streamedToolCalls.some((toolCall) => toolCall.providerExecuted === true);
-    // A non-finalized call whose only accumulated arguments are a bare
-    // empty-object placeholder is provisional streamed input the model never
-    // committed. We can recover by re-calling the model, so it must not block
-    // continuation (unlike a truncated/dead partial-JSON call).
-    const hasIncompleteDeadToolCall = streamedToolCalls.some((toolCall) => isStreamedToolCallIncomplete(toolCall) &&
-        !isRecoverablePlaceholderToolCall(toolCall));
-    const hasRecoverablePlaceholderToolCall = streamedToolCalls.some(isRecoverablePlaceholderToolCall);
-    if (state.finishReason === "tool-calls") {
-        if (hasIncompleteDeadToolCall) {
-            return false;
-        }
-        if (hasProviderExecutedToolCall && !hasFinalizedClientToolCall) {
-            return false;
-        }
-        // Recover provisional placeholders by re-calling the model even when no
-        // client tool call finalized in this step.
-        if (hasRecoverablePlaceholderToolCall && !hasFinalizedClientToolCall) {
-            return true;
-        }
-        return !hasIncompleteToolCall && hasFinalizedClientToolCall;
-    }
-    if (state.finishReason !== "stop") {
-        return false;
-    }
-    if (state.accumulatedText.trim().length > 0) {
-        return false;
-    }
-    const finalToolResults = collectFinalStreamToolResults(state);
-    if (!finalToolResults.size) {
-        for (const toolCall of state.toolCalls.values()) {
-            if (toolCall.inputAvailable !== true || toolCall.providerExecuted === true) {
-                return false;
-            }
-        }
-        return true;
-    }
-    for (const [toolCallId, toolCall] of state.toolCalls) {
-        const toolResult = finalToolResults.get(toolCallId);
-        if (!toolResult) {
-            return false;
-        }
-        if (toolCall.providerExecuted !== true && toolResult.providerExecuted !== true) {
-            return false;
-        }
-    }
-    return true;
-}
-export function captureStreamedToolCallInput(toolCall) {
-    const { args, error } = parseToolArgs(toolCall.arguments);
-    return {
-        args,
-        ...(toolCall.arguments.length > 0 ? { inputText: toolCall.arguments } : {}),
-        ...(error ? { parseError: error } : {}),
-    };
-}
-/**
- * A streamed tool call is "incomplete" when the provider stream terminated
- * (abort, stall, timeout, transport error) before the SDK emitted the
- * finalizing `tool-call` event that sets `inputAvailable: true`. In that state
- * `arguments` only holds partial JSON fragments from `tool-input-delta` events,
- * so the tool call is NOT a committed model choice and must not be parsed or
- * executed. This is semantically distinct from a parse failure on a finalized
- * tool call (`inputAvailable: true` but malformed JSON — which only happens on
- * genuine provider bugs) and needs to be reported as a stream-termination
- * error rather than a tool-argument error.
- */
-export function isStreamedToolCallIncomplete(toolCall) {
-    return toolCall.inputAvailable !== true;
-}
-/**
- * A non-finalized streamed tool call is a "recoverable placeholder" when its
- * accumulated `arguments` are empty or only the transient empty-object
- * placeholder `"{}"` (after stripping leading placeholders). This happens when
- * a provider emits `tool-input-start` + a `"{}"` `tool-input-delta` and then
- * finishes the step WITHOUT ever sending the finalizing `tool-call` /
- * `tool-input-end` event — the model never actually committed any arguments.
- *
- * Unlike an incomplete-dead tool call (which carries real truncated partial
- * JSON and must stop the loop to avoid retry storms), a recoverable
- * placeholder carries no committed intent, so the runtime can safely re-call
- * the model to recover the real tool call. Such placeholders must NOT be
- * executed and must NOT surface a stream-termination error.
- */
-export function isRecoverablePlaceholderToolCall(toolCall) {
-    if (!isStreamedToolCallIncomplete(toolCall)) {
-        return false;
-    }
-    const stripped = stripLeadingEmptyObjectPlaceholder(toolCall.arguments);
-    return stripped === "" || stripped === "{}";
-}
-/**
- * Classify and build the persisted `MessagePart` for a single streamed tool
- * call. Pure function — no logging, no SSE, no memory. Callers decide what to
- * do with the result so this stays unit-testable.
- *
- * The resulting `part` is always pushed into the assistant message so the
- * conversation history is transparent: even incomplete tool calls leave a
- * visible trace with their partial `inputText`. What differs is the caller's
- * error-surfacing behavior (log warning, SSE event, tool-result error).
- */
-export function materializeStreamedToolCall(tc) {
-    const providerExecutedPart = tc.providerExecuted === true
-        ? { providerExecuted: true }
-        : {};
-    const basePart = {
-        type: `tool-${tc.name}`,
-        toolCallId: tc.id,
-        toolName: tc.name,
-        args: {},
-        ...(tc.arguments.length > 0 ? { inputText: tc.arguments } : {}),
-        ...providerExecutedPart,
-    };
-    if (isStreamedToolCallIncomplete(tc)) {
-        return {
-            kind: "incomplete",
-            part: basePart,
-            partialArgumentsLength: tc.arguments.length,
-            partialArgumentsPreview: tc.arguments.slice(0, 200),
-        };
-    }
-    const capturedInput = captureStreamedToolCallInput(tc);
-    const part = {
-        type: `tool-${tc.name}`,
-        toolCallId: tc.id,
-        toolName: tc.name,
-        args: capturedInput.args,
-        ...(capturedInput.inputText ? { inputText: capturedInput.inputText } : {}),
-        ...providerExecutedPart,
-    };
-    if (capturedInput.parseError) {
-        return { kind: "parse-error", part, parseError: capturedInput.parseError };
-    }
-    return { kind: "complete", part };
-}
-function isToolResultPart(part) {
-    return part.type === "tool-result" && "result" in part;
-}
-function hydrateActiveSkillStateFromMessages(messages) {
-    let activeSkillPolicy;
-    let activeSkillDelegationOverrides;
-    for (const message of messages) {
-        for (const part of message.parts) {
-            if (!isToolResultPart(part) || part.toolName !== LOAD_SKILL_TOOL_ID)
-                continue;
-            activeSkillPolicy = extractSkillPolicy(part.result);
-            activeSkillDelegationOverrides = extractSkillDelegationOverrides(part.result);
-        }
-    }
-    return { activeSkillPolicy, activeSkillDelegationOverrides };
-}
-/**
- * Extract and validate the skill policy from a load_skill tool result.
- * Returns `[]` (no tools allowed) for invalid/missing policies instead of
- * `undefined` (no restrictions), preventing accidental policy bypass.
- */
-export function extractSkillPolicy(result) {
-    if (!result || typeof result !== "object")
-        return undefined;
-    const skillResult = result;
-    // No allowedTools key means the skill has no restrictions
-    if (!("allowedTools" in skillResult) || skillResult.allowedTools === undefined) {
-        return undefined;
-    }
-    // Validate the shape: must be a string array
-    const raw = skillResult.allowedTools;
-    if (!Array.isArray(raw) || !raw.every((v) => typeof v === "string")) {
-        // Invalid shape — fail closed (empty policy = no tools allowed)
-        logger.warn("load_skill returned invalid allowedTools; falling back to empty policy (no tools)");
-        return [];
-    }
-    // Validate each pattern against the regex
-    try {
-        return validateAllowedToolPatterns(raw);
-    }
-    catch (error) {
-        logger.warn("load_skill returned invalid tool patterns; falling back to empty policy (no tools)", { error });
-        return [];
-    }
-}
-/**
- * Enforce skill policy on a single tool call.
- * Shared between generate() and stream() paths.
- */
-export function enforceSkillPolicy(toolName, activeSkillPolicy, mustLoadSkillFirst) {
-    // Must load skill before other tools
-    if (mustLoadSkillFirst && toolName !== LOAD_SKILL_TOOL_ID) {
-        return { allowed: false, error: getSkillActivationRequiredError(toolName) };
-    }
-    // Check tool allowed by active skill policy (Layer 2: execution-time)
-    if (activeSkillPolicy && !isToolAllowedBySkill(toolName, activeSkillPolicy)) {
-        return {
-            allowed: false,
-            error: `Tool "${toolName}" is not allowed by the active skill policy. Allowed: ${activeSkillPolicy.join(", ")}`,
-        };
-    }
-    return { allowed: true };
-}
-function getRuntimeAllowedRemoteTools(config) {
-    const configWithRuntimeFilters = config;
-    if (!Object.hasOwn(configWithRuntimeFilters, "__vfAllowedRemoteTools")) {
-        return undefined;
-    }
-    const raw = configWithRuntimeFilters.__vfAllowedRemoteTools;
-    if (!Array.isArray(raw)) {
-        return [];
-    }
-    return raw.every((toolName) => typeof toolName === "string") ? raw : [];
-}
-function getRuntimeProviderTools(config) {
-    const raw = config.providerTools;
-    if (!Array.isArray(raw)) {
-        return [];
-    }
-    return raw.every((toolName) => typeof toolName === "string") ? raw : [];
-}
-function getRuntimeForwardedIntegrationToolDefs(config) {
-    const configWithFilters = config;
-    const raw = configWithFilters.__vfForwardedIntegrationToolDefs;
-    if (!Array.isArray(raw) || raw.length === 0)
-        return undefined;
-    return raw
-        .filter((def) => typeof def === "object" &&
-        def !== null &&
-        typeof def.name === "string" &&
-        typeof def.description === "string")
-        .map((def) => ({
-        name: def.name,
-        description: def.description,
-        parameters: typeof def.parameters === "object" && def.parameters !== null &&
-            !Array.isArray(def.parameters)
-            ? def.parameters
-            : { type: "object", properties: {} },
-    }));
-}
 /** Implement agent runtime. */
 export class AgentRuntime {
     id;
@@ -470,7 +145,7 @@ export class AgentRuntime {
             return chain.execute(agentContext, () => this.executeAgentLoop(systemPrompt, messages, {
                 agentId: this.id,
                 projectId: tryGetCacheKeyContext()?.projectId,
-            }, context, resolvedModelString, transport.languageModel, transport.headers, transport.providerOptions, maxOutputTokensOverride));
+            }, context, resolvedModelString, transport.languageModel, transport.headers, transport.providerOptions, maxOutputTokensOverride, requestedModel));
         });
     }
     /**
@@ -551,7 +226,7 @@ export class AgentRuntime {
                             model: effectiveModel,
                         },
                     });
-                    const response = await chain.execute(agentContext, () => this.executeAgentLoopStreaming(systemPrompt, memoryMessages, controller, encoder, callbacks, textPartId, toolContext, context, resolvedModelString, languageModel, transport.headers, transport.providerOptions, maxOutputTokensOverride, streamAbortSignal));
+                    const response = await chain.execute(agentContext, () => this.executeAgentLoopStreaming(systemPrompt, memoryMessages, controller, encoder, callbacks, textPartId, toolContext, context, resolvedModelString, languageModel, transport.headers, transport.providerOptions, maxOutputTokensOverride, streamAbortSignal, requestedModel));
                     throwIfAborted(streamAbortSignal);
                     callbacks?.onFinish?.(response);
                     throwIfAborted(streamAbortSignal);
@@ -583,7 +258,7 @@ export class AgentRuntime {
     /**
      * Execute agent loop (with tool calling)
      */
-    async executeAgentLoop(systemPrompt, messages, toolContextBase, runtimeContext, modelString, resolvedModel, headers, providerOptions, maxOutputTokensOverride) {
+    async executeAgentLoop(systemPrompt, messages, toolContextBase, runtimeContext, modelString, resolvedModel, headers, providerOptions, maxOutputTokensOverride, temperatureModelString) {
         return withSpan("agent.execution_loop", async (loopSpan) => {
             const { maxAgentSteps } = getPlatformCapabilities();
             const maxSteps = this.computeMaxSteps(maxAgentSteps);
@@ -625,6 +300,7 @@ export class AgentRuntime {
                 if (activeSkillPolicy) {
                     tools = filterToolsForSkill(tools, activeSkillPolicy);
                 }
+                const temperature = this.resolveTemperature(temperatureModelString ?? effectiveModel);
                 const response = await withSpan("agent.generate_text", async (span) => {
                     setSpanAttributes(span, {
                         "model.id": effectiveModel,
@@ -640,7 +316,7 @@ export class AgentRuntime {
                         }),
                         experimental_repairToolCall: repairToolCall,
                         maxOutputTokens: this.resolveMaxOutputTokens(effectiveModel, maxOutputTokensOverride),
-                        temperature: this.resolveTemperature(),
+                        ...(temperature === undefined ? {} : { temperature }),
                         ...(headers ? { headers } : {}),
                         ...(providerOptions ? { providerOptions } : {}),
                     });
@@ -803,7 +479,7 @@ export class AgentRuntime {
      * Emits veryfront stream events (message-start/message-finish + step-start/step-end)
      * while consuming model-runtime `streamText()` parts internally.
      */
-    async executeAgentLoopStreaming(systemPrompt, messages, controller, encoder, callbacks, textPartId, toolContextBase, runtimeContext, modelString, resolvedModel, headers, providerOptions, maxOutputTokensOverride, abortSignal) {
+    async executeAgentLoopStreaming(systemPrompt, messages, controller, encoder, callbacks, textPartId, toolContextBase, runtimeContext, modelString, resolvedModel, headers, providerOptions, maxOutputTokensOverride, abortSignal, temperatureModelString) {
         const { maxAgentSteps } = getPlatformCapabilities();
         const maxSteps = this.computeMaxSteps(maxAgentSteps);
         const effectiveModel = resolveRuntimeModel(modelString || this.config.model);
@@ -851,6 +527,7 @@ export class AgentRuntime {
                 model: effectiveModel,
                 providerTools,
             });
+            const temperature = this.resolveTemperature(temperatureModelString ?? effectiveModel);
             const result = streamText({
                 model: languageModel,
                 system: currentSystemPrompt,
@@ -858,7 +535,7 @@ export class AgentRuntime {
                 tools: runtimeTools,
                 experimental_repairToolCall: repairToolCall,
                 maxOutputTokens: this.resolveMaxOutputTokens(effectiveModel, maxOutputTokensOverride),
-                temperature: this.resolveTemperature(),
+                ...(temperature === undefined ? {} : { temperature }),
                 ...(headers ? { headers } : {}),
                 ...(providerOptions ? { providerOptions } : {}),
                 abortSignal,
@@ -1141,7 +818,10 @@ export class AgentRuntime {
         const edgeMaxSteps = this.config.edge?.enabled ? this.config.edge.maxSteps : undefined;
         return getMaxSteps(this.config.maxSteps, edgeMaxSteps, platformLimit);
     }
-    resolveTemperature() {
+    resolveTemperature(modelString) {
+        if (!supportsTemperatureParameter(modelString)) {
+            return undefined;
+        }
         return this.config.temperature ?? DEFAULT_TEMPERATURE;
     }
     resolveMaxOutputTokens(modelString, maxOutputTokensOverride) {

package/esm/src/agent/runtime/model-capabilities.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeModelCapabilityId(modelString?: string): string | undefined;
+export declare function supportsTemperatureParameter(modelString?: string): boolean;
+//# sourceMappingURL=model-capabilities.d.ts.map

package/esm/src/agent/runtime/model-capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-capabilities.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/runtime/model-capabilities.ts"],"names":[],"mappings":"AAOA,wBAAgB,0BAA0B,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKnF;AAED,wBAAgB,4BAA4B,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAI1E"}

package/esm/src/agent/runtime/model-capabilities.js

@@ -0,0 +1,18 @@
+const VERYFRONT_CLOUD_MODEL_PREFIX = "veryfront-cloud/";
+const MODELS_WITHOUT_TEMPERATURE_PARAMETER = new Set([
+    "anthropic/claude-opus-4-7",
+    "anthropic/claude-opus-4-8",
+]);
+export function normalizeModelCapabilityId(modelString) {
+    if (!modelString)
+        return undefined;
+    return modelString.startsWith(VERYFRONT_CLOUD_MODEL_PREFIX)
+        ? modelString.slice(VERYFRONT_CLOUD_MODEL_PREFIX.length)
+        : modelString;
+}
+export function supportsTemperatureParameter(modelString) {
+    const normalizedModel = normalizeModelCapabilityId(modelString);
+    if (!normalizedModel)
+        return true;
+    return !MODELS_WITHOUT_TEMPERATURE_PARAMETER.has(normalizedModel);
+}

package/esm/src/agent/runtime/runtime-tool-config.d.ts

@@ -0,0 +1,14 @@
+import type { ToolDefinition } from "../../tool/index.js";
+import type { AgentConfig } from "../types.js";
+import type { RuntimeRemoteToolConfig } from "./mcp-server-tool-sources.js";
+export type RuntimeToolFilterConfig = AgentConfig & {
+    __vfForwardedIntegrationToolDefs?: Array<{
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    }>;
+} & RuntimeRemoteToolConfig;
+export declare function getRuntimeAllowedRemoteTools(config: AgentConfig): string[] | undefined;
+export declare function getRuntimeProviderTools(config: AgentConfig): string[];
+export declare function getRuntimeForwardedIntegrationToolDefs(config: AgentConfig): ToolDefinition[] | undefined;
+//# sourceMappingURL=runtime-tool-config.d.ts.map

package/esm/src/agent/runtime/runtime-tool-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-tool-config.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/runtime/runtime-tool-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAE5E,MAAM,MAAM,uBAAuB,GAAG,WAAW,GAAG;IAClD,gCAAgC,CAAC,EAAE,KAAK,CACtC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAC3E,CAAC;CACH,GAAG,uBAAuB,CAAC;AAE5B,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,EAAE,GAAG,SAAS,CAUtF;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,EAAE,CAMrE;AAED,wBAAgB,sCAAsC,CACpD,MAAM,EAAE,WAAW,GAClB,cAAc,EAAE,GAAG,SAAS,CAoB9B"}

package/esm/src/agent/runtime/runtime-tool-config.js

@@ -0,0 +1,37 @@
+export function getRuntimeAllowedRemoteTools(config) {
+    const configWithRuntimeFilters = config;
+    if (!Object.hasOwn(configWithRuntimeFilters, "__vfAllowedRemoteTools")) {
+        return undefined;
+    }
+    const raw = configWithRuntimeFilters.__vfAllowedRemoteTools;
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    return raw.every((toolName) => typeof toolName === "string") ? raw : [];
+}
+export function getRuntimeProviderTools(config) {
+    const raw = config.providerTools;
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    return raw.every((toolName) => typeof toolName === "string") ? raw : [];
+}
+export function getRuntimeForwardedIntegrationToolDefs(config) {
+    const configWithFilters = config;
+    const raw = configWithFilters.__vfForwardedIntegrationToolDefs;
+    if (!Array.isArray(raw) || raw.length === 0)
+        return undefined;
+    return raw
+        .filter((def) => typeof def === "object" &&
+        def !== null &&
+        typeof def.name === "string" &&
+        typeof def.description === "string")
+        .map((def) => ({
+        name: def.name,
+        description: def.description,
+        parameters: typeof def.parameters === "object" && def.parameters !== null &&
+            !Array.isArray(def.parameters)
+            ? def.parameters
+            : { type: "object", properties: {} },
+    }));
+}

package/esm/src/agent/runtime/skill-policy-enforcement.d.ts

@@ -0,0 +1,16 @@
+import type { Message } from "../types.js";
+import { type SkillDelegationOverrides } from "./skill-delegation-overrides.js";
+export declare const LOAD_SKILL_TOOL_ID = "load_skill";
+export declare function hydrateActiveSkillStateFromMessages(messages: readonly Message[]): {
+    activeSkillPolicy: string[] | undefined;
+    activeSkillDelegationOverrides: SkillDelegationOverrides | undefined;
+};
+export declare function extractSkillPolicy(result: unknown): string[] | undefined;
+export type SkillPolicyResult = {
+    allowed: true;
+} | {
+    allowed: false;
+    error: string;
+};
+export declare function enforceSkillPolicy(toolName: string, activeSkillPolicy: string[] | undefined, mustLoadSkillFirst: boolean): SkillPolicyResult;
+//# sourceMappingURL=skill-policy-enforcement.d.ts.map

package/esm/src/agent/runtime/skill-policy-enforcement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-policy-enforcement.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/runtime/skill-policy-enforcement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAO3C,OAAO,EAEL,KAAK,wBAAwB,EAC9B,MAAM,iCAAiC,CAAC;AAIzC,eAAO,MAAM,kBAAkB,eAAe,CAAC;AAO/C,wBAAgB,mCAAmC,CACjD,QAAQ,EAAE,SAAS,OAAO,EAAE,GAC3B;IACD,iBAAiB,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IACxC,8BAA8B,EAAE,wBAAwB,GAAG,SAAS,CAAC;CACtE,CAaA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,EAAE,GAAG,SAAS,CAyBxE;AAED,MAAM,MAAM,iBAAiB,GACzB;IAAE,OAAO,EAAE,IAAI,CAAA;CAAE,GACjB;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtC,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,iBAAiB,EAAE,MAAM,EAAE,GAAG,SAAS,EACvC,kBAAkB,EAAE,OAAO,GAC1B,iBAAiB,CAenB"}

package/esm/src/agent/runtime/skill-policy-enforcement.js

@@ -0,0 +1,55 @@
+import { serverLogger } from "../../utils/index.js";
+import { isToolAllowedBySkill, validateAllowedToolPatterns, } from "../../skill/allowed-tools.js";
+import { isToolResultPart } from "./tool-result-continuation.js";
+import { extractSkillDelegationOverrides, } from "./skill-delegation-overrides.js";
+const logger = serverLogger.component("agent");
+export const LOAD_SKILL_TOOL_ID = "load_skill";
+function getSkillActivationRequiredError(toolName) {
+    return `Tool "${toolName}" cannot run before load_skill succeeds in the same step. ` +
+        `Call "${LOAD_SKILL_TOOL_ID}" first to establish the active skill context.`;
+}
+export function hydrateActiveSkillStateFromMessages(messages) {
+    let activeSkillPolicy;
+    let activeSkillDelegationOverrides;
+    for (const message of messages) {
+        for (const part of message.parts) {
+            if (!isToolResultPart(part) || part.toolName !== LOAD_SKILL_TOOL_ID)
+                continue;
+            activeSkillPolicy = extractSkillPolicy(part.result);
+            activeSkillDelegationOverrides = extractSkillDelegationOverrides(part.result);
+        }
+    }
+    return { activeSkillPolicy, activeSkillDelegationOverrides };
+}
+export function extractSkillPolicy(result) {
+    if (!result || typeof result !== "object")
+        return undefined;
+    const skillResult = result;
+    if (!("allowedTools" in skillResult) || skillResult.allowedTools === undefined) {
+        return undefined;
+    }
+    const raw = skillResult.allowedTools;
+    if (!Array.isArray(raw) || !raw.every((v) => typeof v === "string")) {
+        logger.warn("load_skill returned invalid allowedTools; falling back to empty policy (no tools)");
+        return [];
+    }
+    try {
+        return validateAllowedToolPatterns(raw);
+    }
+    catch (error) {
+        logger.warn("load_skill returned invalid tool patterns; falling back to empty policy (no tools)", { error });
+        return [];
+    }
+}
+export function enforceSkillPolicy(toolName, activeSkillPolicy, mustLoadSkillFirst) {
+    if (mustLoadSkillFirst && toolName !== LOAD_SKILL_TOOL_ID) {
+        return { allowed: false, error: getSkillActivationRequiredError(toolName) };
+    }
+    if (activeSkillPolicy && !isToolAllowedBySkill(toolName, activeSkillPolicy)) {
+        return {
+            allowed: false,
+            error: `Tool "${toolName}" is not allowed by the active skill policy. Allowed: ${activeSkillPolicy.join(", ")}`,
+        };
+    }
+    return { allowed: true };
+}

package/esm/src/agent/runtime/tool-result-continuation.d.ts

@@ -0,0 +1,34 @@
+import { type Message, type MessagePart, type ToolResultPart } from "../types.js";
+import type { ChatStreamState, StreamingToolCall, StreamingToolResult } from "./chat-stream-handler.js";
+import type { RuntimeGenerateToolResult, RuntimeToolSet } from "./runtime-tool-types.js";
+export declare function getToolResultError(result: unknown): string | undefined;
+export declare function createToolResultMessage(toolCallId: string, toolName: string, result: unknown, providerExecuted?: boolean): Message;
+export declare function createToolErrorMessage(toolCallId: string, toolName: string, error: string): Message;
+export declare function getProviderExecutedToolNames(runtimeTools: RuntimeToolSet | undefined): string[];
+export declare function collectFinalStreamToolResults(state: Pick<ChatStreamState, "toolResults">): Map<string, StreamingToolResult>;
+export declare function collectPersistedToolResults(messages: Message[]): Map<string, ToolResultPart>;
+export declare function collectGeneratedToolResults(toolResults: RuntimeGenerateToolResult[] | undefined): Map<string, RuntimeGenerateToolResult>;
+export declare function shouldContinueAfterStreamStep(state: Pick<ChatStreamState, "accumulatedText" | "finishReason" | "toolCalls" | "toolResults">): boolean;
+export declare function captureStreamedToolCallInput(toolCall: Pick<StreamingToolCall, "arguments">): {
+    args: Record<string, unknown>;
+    inputText?: string;
+    parseError?: string;
+};
+export declare function isStreamedToolCallIncomplete(toolCall: Pick<StreamingToolCall, "inputAvailable">): boolean;
+export declare function isRecoverablePlaceholderToolCall(toolCall: Pick<StreamingToolCall, "inputAvailable" | "arguments">): boolean;
+export type StreamedToolCallMaterialization = {
+    readonly kind: "complete";
+    readonly part: MessagePart;
+} | {
+    readonly kind: "parse-error";
+    readonly part: MessagePart;
+    readonly parseError: string;
+} | {
+    readonly kind: "incomplete";
+    readonly part: MessagePart;
+    readonly partialArgumentsLength: number;
+    readonly partialArgumentsPreview: string;
+};
+export declare function materializeStreamedToolCall(tc: StreamingToolCall): StreamedToolCallMaterialization;
+export declare function isToolResultPart(part: MessagePart): part is ToolResultPart;
+//# sourceMappingURL=tool-result-continuation.d.ts.map