@theia/ai-core 1.77.0-next.4 → 1.77.0-next.47

package/src/browser/reasoning-labels.ts

@@ -0,0 +1,41 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { nls } from '@theia/core/lib/common/nls';
+import { ReasoningLevel } from '../common/language-model';
+
+export function reasoningLevelLabel(level: ReasoningLevel): string {
+    switch (level) {
+        case 'off': return nls.localizeByDefault('Off');
+        case 'none': return nls.localizeByDefault('None');
+        case 'minimal': return nls.localizeByDefault('Minimal');
+        case 'low': return nls.localizeByDefault('Low');
+        case 'medium': return nls.localizeByDefault('Medium');
+        case 'high': return nls.localizeByDefault('High');
+        case 'xhigh': return nls.localizeByDefault('Extra High');
+        case 'max': return nls.localizeByDefault('Max');
+        case 'auto': return nls.localizeByDefault('Auto');
+    }
+}
+
+export function reasoningLevelDescription(level: ReasoningLevel): string | undefined {
+    switch (level) {
+        case 'off': return nls.localize('theia/ai/core/reasoning/offDescription',
+            'Omits explicit reasoning effort, allowing provider defaults or raw request settings to apply; on Ollama, disables thinking.');
+        case 'none': return nls.localize('theia/ai/core/reasoning/noneDescription', 'Explicitly requests no reasoning.');
+        default: return undefined;
+    }
+}

package/src/common/ai-core-preferences.ts

@@ -240,11 +240,14 @@ export const aiCorePreferenceSchema: PreferenceSchema = {
                 + ' `#ai-features.modelSettings.requestSettings#` for the same fields.\n\n'
                 + 'Each entry consists of:\n'
                 + '- `scope`: Defines when the setting applies (`modelId`, `providerId`, `agentId`).\n'
-                + '- `reasoning.level`: One of `off`, `minimal`, `low`, `medium`, `high`, `auto`.\n\n'
+                + '- `reasoning.level`: One of `off`, `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`, `auto`.\n'
+                + 'Supported levels depend on the model. `none` explicitly requests no reasoning; `off` disables thinking'
+                + ' on Ollama. For other providers, `off` omits explicit reasoning effort, allowing provider defaults'
+                + ' or raw request settings to apply. `auto` uses the provider default.\n\n'
                 + 'Precedence at runtime (highest first): session override via the selector → this preference →'
                 + ' the model\'s declared default. Whichever the selector displays is what gets sent. To override'
                 + ' a provider\'s reasoning field manually via `#ai-features.modelSettings.requestSettings#`, set'
-                + ' `reasoning.level` to `off` here so the level-based translation is disabled.\n\n'
+                + ' `reasoning.level` to `off` here so the level-based translation is disabled (except on Ollama).\n\n'
                 + 'Entries are matched based on scope specificity (agent: 100, model: 10, provider: 1 points).\n\n'
                 + 'Example:\n'
                 + '```json\n'
@@ -272,7 +275,7 @@ export const aiCorePreferenceSchema: PreferenceSchema = {
                         properties: {
                             level: {
                                 type: 'string',
-                                enum: ['off', 'minimal', 'low', 'medium', 'high', 'auto'],
+                                enum: ['off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'auto'],
                                 default: 'auto'
                             }
                         },

package/src/common/index.ts

@@ -22,6 +22,7 @@ export * from './language-model-delegate';
 export * from './language-model-util';
 export * from './language-model';
 export * from './language-model-alias';
+export * from './tool-call-execution';
 export * from './model-discovery-status';
 export * from './model-discovery-util';
 export * from './prompt-service';

package/src/common/language-model-service.spec.ts

@@ -16,7 +16,7 @@
 
 import { expect } from 'chai';
 import { LanguageModelServiceImpl } from './language-model-service';
-import { LanguageModel, LanguageModelMessage, UserRequest } from './language-model';
+import { LanguageModel, LanguageModelMessage, ReasoningLevel, ReasoningSupport, UserRequest } from './language-model';
 
 describe('LanguageModelServiceImpl message filtering', () => {
 
@@ -33,6 +33,28 @@ describe('LanguageModelServiceImpl message filtering', () => {
         return { model, captured: () => capturedMessages };
     }
 
+    for (const [support, requested, expected] of [
+        [{ supportedLevels: ['off', 'minimal', 'low', 'auto'] }, 'none', 'off'],
+        [{ supportedLevels: ['off', 'low', 'medium', 'high', 'auto'] }, 'max', 'high'],
+        [{ supportedLevels: ['none', 'low'] }, 'minimal', 'low'],
+        [undefined, 'max', 'max']
+    ] satisfies [ReasoningSupport | undefined, ReasoningLevel, ReasoningLevel][]) {
+        it(`clamps ${requested} to ${expected} in the common request path with support ${JSON.stringify(support)}`, async () => {
+            const service = new LanguageModelServiceImpl();
+            const reasoning = { level: requested };
+            const model: LanguageModel = {
+                id: 'test', name: 'test', vendor: 'test', version: '1', status: { status: 'ready' }, reasoningSupport: support,
+                async request(request): Promise<{ text: string }> {
+                    expect(request.reasoning?.level).to.equal(expected);
+                    return { text: '' };
+                }
+            };
+            await service.sendRequest(model, { messages: [], sessionId: 'session', requestId: 'req', reasoning });
+            expect(reasoning.level).to.equal(requested);
+            expect(service.sessions[0].exchanges[0].requests[0].request.reasoning?.level).to.equal(expected);
+        });
+    }
+
     function baseMessages(): LanguageModelMessage[] {
         return [
             { actor: 'user', type: 'text', text: 'hi' },

package/src/common/language-model-service.ts

@@ -15,7 +15,9 @@
 // *****************************************************************************
 
 import { inject } from '@theia/core/shared/inversify';
-import { isLanguageModelStreamResponse, LanguageModel, LanguageModelRegistry, LanguageModelResponse, LanguageModelStreamResponsePart, UserRequest } from './language-model';
+import {
+    isLanguageModelStreamResponse, LanguageModel, LanguageModelRegistry, LanguageModelResponse, LanguageModelStreamResponsePart, ReasoningSupport, UserRequest
+} from './language-model';
 import { LanguageModelExchangeRequest, LanguageModelSession } from './language-model-interaction-model';
 import { Emitter } from '@theia/core';
 
@@ -72,6 +74,14 @@ export class LanguageModelServiceImpl implements LanguageModelService {
         languageModel: LanguageModel,
         languageModelRequest: UserRequest
     ): Promise<LanguageModelResponse> {
+        // Clamp persisted selections and direct requests to the model's declared reasoning levels.
+        if (languageModelRequest.reasoning && languageModel.reasoningSupport) {
+            const level = ReasoningSupport.clampLevel(languageModel.reasoningSupport, languageModelRequest.reasoning.level);
+            if (level !== languageModelRequest.reasoning.level) {
+                languageModelRequest.reasoning = { ...languageModelRequest.reasoning, level };
+            }
+        }
+
         // Filter messages based on client settings
         languageModelRequest.messages = languageModelRequest.messages.filter(message => {
             if (message.type === 'thinking' && languageModelRequest.clientSettings?.keepThinking === false) {

package/src/common/language-model.spec.ts

@@ -367,8 +367,29 @@ describe('ReasoningSupport.clampLevel', () => {
         expect(ReasoningSupport.clampLevel(oSeries, 'auto')).to.equal('auto');
     });
 
+    it('passes through native none, xhigh, and max when supported', () => {
+        const support: ReasoningSupport = { supportedLevels: ['none', 'low', 'medium', 'high', 'xhigh', 'max', 'auto'] };
+        for (const level of support.supportedLevels) {
+            expect(ReasoningSupport.clampLevel(support, level)).to.equal(level);
+        }
+    });
+
+    it('clamps extended efforts to older models and max to max-only models', () => {
+        expect(ReasoningSupport.clampLevel(oSeries, 'xhigh')).to.equal('high');
+        expect(ReasoningSupport.clampLevel(oSeries, 'max')).to.equal('high');
+        expect(ReasoningSupport.clampLevel({ supportedLevels: ['low', 'medium', 'high', 'max'] }, 'xhigh')).to.equal('max');
+        expect(ReasoningSupport.clampLevel({ supportedLevels: ['low', 'medium', 'high', 'xhigh'] }, 'max')).to.equal('xhigh');
+    });
+
+    it('clamps none to the nearest supported effort', () => {
+        expect(ReasoningSupport.clampLevel({ supportedLevels: ['low', 'medium', 'high'] }, 'none')).to.equal('low');
+        expect(ReasoningSupport.clampLevel(oSeries, 'none')).to.equal('off');
+        expect(ReasoningSupport.clampLevel({ supportedLevels: ['off', 'minimal', 'low', 'auto'] }, 'none')).to.equal('off');
+    });
+
     it('raises an unsupported minimal to low rather than lowering it to off', () => {
         expect(ReasoningSupport.clampLevel(oSeries, 'minimal')).to.equal('low');
+        expect(ReasoningSupport.clampLevel({ supportedLevels: ['none', 'low'] }, 'minimal')).to.equal('low');
     });
 
     it('lowers an unsupported level when nothing higher is supported', () => {

package/src/common/language-model.ts

@@ -20,7 +20,7 @@ import { inject, injectable, named, postConstruct } from '@theia/core/shared/inv
 export type MessageActor = 'user' | 'ai' | 'system';
 
 /** Provider-agnostic reasoning level; each provider maps this to its native API. */
-export type ReasoningLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'auto';
+export type ReasoningLevel = 'off' | 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max' | 'auto';
 
 export interface ReasoningSettings {
     level: ReasoningLevel;
@@ -43,11 +43,12 @@ export interface ReasoningSupport {
 }
 export namespace ReasoningSupport {
     /** Levels ordered by increasing effort; `'auto'` sits outside the scale. */
-    const EFFORT_SCALE: ReadonlyArray<ReasoningLevel> = ['off', 'minimal', 'low', 'medium', 'high'];
+    const EFFORT_SCALE: ReadonlyArray<ReasoningLevel> = ['off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
 
     /**
      * Returns `level` when `support` lists it, otherwise the nearest supported level on the effort scale,
-     * preferring the higher neighbour (an unsupported `minimal` becomes `low`, not `off`). An unsupported
+     * preferring the higher neighbour (an unsupported `minimal` becomes `low`, not `off`), except that
+     * unsupported `'none'` prefers `'off'` to avoid enabling reasoning. An unsupported
      * `'auto'` resolves to `defaultLevel`, then to the first supported level. Returns `level` unchanged
      * when nothing suitable is supported.
      */
@@ -56,6 +57,9 @@ export namespace ReasoningSupport {
         if (supported.includes(level)) {
             return level;
         }
+        if (level === 'none' && supported.includes('off')) {
+            return 'off';
+        }
         if (level === 'auto') {
             return support.defaultLevel && supported.includes(support.defaultLevel) ? support.defaultLevel : supported[0] ?? level;
         }
@@ -188,8 +192,15 @@ export interface AutoActionResult {
     reason?: string;
 }
 
+/**
+ * The primitive JSON Schema types allowed in a {@link ToolRequestParameterProperty}.
+ * Follows JSON Schema 2020-12 / MCP: a property may declare a single type or a
+ * union of types (e.g. `type: ["string", "null"]`).
+ */
+export type ToolRequestParameterType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+
 export interface ToolRequestParameterProperty {
-    type?: | 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+    type?: ToolRequestParameterType | ToolRequestParameterType[];
     anyOf?: ToolRequestParameterProperty[];
     [key: string]: unknown;
 }
@@ -326,8 +337,17 @@ export namespace ToolRequest {
                 }
             }
         }
-        if ('type' in record && typeof record.type !== 'string') {
-            return false;
+        if ('type' in record) {
+            if (typeof record.type !== 'string' && !Array.isArray(record.type)) {
+                return false;
+            }
+            if (Array.isArray(record.type)) {
+                for (const typeItem of record.type) {
+                    if (typeof typeItem !== 'string') {
+                        return false;
+                    }
+                }
+            }
         }
 
         // No further checks required for additional properties.

package/src/common/tool-call-execution.spec.ts

@@ -0,0 +1,162 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from 'chai';
+import { CancellationToken, CancellationTokenSource, ILogger } from '@theia/core';
+import { Container } from '@theia/core/shared/inversify';
+import { MockLogger } from '@theia/core/lib/common/test/mock-logger';
+import { Deferred } from '@theia/core/lib/common/promise-util';
+import {
+    ToolRequest,
+    ToolInvocationContext,
+    hasToolCallError,
+    isToolNotAvailableError,
+    isToolCallContent
+} from './language-model';
+import { ToolCallExecutor, ToolCallExecutorImpl, ToolCallOutcome } from './tool-call-execution';
+
+/** Builds a minimal {@link ToolRequest} whose handler delegates to `handler`. */
+function tool(name: string, handler: ToolRequest['handler']): ToolRequest {
+    return { id: name, name, parameters: { type: 'object', properties: {} }, handler };
+}
+
+describe('ToolCallExecutor', () => {
+    let executor: ToolCallExecutor;
+
+    beforeEach(() => {
+        const container = new Container();
+        container.bind(ILogger).to(MockLogger);
+        container.bind(ToolCallExecutorImpl).toSelf();
+        executor = container.get(ToolCallExecutorImpl);
+    });
+
+    it('executes the tool calls of a turn concurrently (not sequentially)', async () => {
+        // `a` only completes once `b` has started. A sequential implementation that runs
+        // `a` before `b` would deadlock here, so this is the core regression test for #17533.
+        const bStarted = new Deferred<void>();
+        const tools = [
+            tool('a', async () => {
+                await bStarted.promise;
+                return 'a-done';
+            }),
+            tool('b', async () => {
+                bStarted.resolve();
+                return 'b-done';
+            })
+        ];
+
+        const results = await executor.executeToolCalls(
+            [{ id: '1', name: 'a', arguments: '{}' }, { id: '2', name: 'b', arguments: '{}' }],
+            tools
+        );
+
+        expect(results.map(r => r.result)).to.deep.equal(['a-done', 'b-done']);
+    });
+
+    it('preserves input order even when calls complete out of order', async () => {
+        const aResolves = new Deferred<void>();
+        const tools = [
+            tool('slow', async () => {
+                await aResolves.promise;
+                return 'slow-done';
+            }),
+            tool('fast', async () => {
+                // Let `fast` finish first, then release `slow`.
+                aResolves.resolve();
+                return 'fast-done';
+            })
+        ];
+
+        const results = await executor.executeToolCalls(
+            [{ id: 'a', name: 'slow', arguments: '{}' }, { id: 'b', name: 'fast', arguments: '{}' }],
+            tools
+        );
+
+        expect(results.map(r => r.id)).to.deep.equal(['a', 'b']);
+        expect(results.map(r => r.result)).to.deep.equal(['slow-done', 'fast-done']);
+    });
+
+    it('reports a tool-not-available error when no tool matches the name', async () => {
+        const results = await executor.executeToolCalls(
+            [{ id: '1', name: 'missing', arguments: '{}' }],
+            [tool('present', async () => 'ok')]
+        );
+
+        expect(results).to.have.lengthOf(1);
+        expect(results[0].notFound).to.equal(true);
+        expect(results[0].error).to.equal(undefined);
+        expect(isToolCallContent(results[0].result)).to.equal(true);
+        expect(isToolCallContent(results[0].result) && results[0].result.content.some(isToolNotAvailableError)).to.equal(true);
+    });
+
+    it('isolates a throwing handler: it does not reject, exposes the error, and siblings still resolve', async () => {
+        const boom = new Error('handler boom');
+        const results = await executor.executeToolCalls(
+            [{ id: '1', name: 'throws', arguments: '{}' }, { id: '2', name: 'ok', arguments: '{}' }],
+            [
+                tool('throws', async () => { throw boom; }),
+                tool('ok', async () => 'ok-result')
+            ]
+        );
+
+        const thrown = results.find(r => r.id === '1')!;
+        const succeeded = results.find(r => r.id === '2')!;
+        expect(thrown.error).to.equal(boom);
+        expect(hasToolCallError(thrown.result)).to.equal(true);
+        expect(thrown.notFound).to.equal(false);
+        expect(succeeded.result).to.equal('ok-result');
+    });
+
+    it('invokes onResult exactly once per tool call', async () => {
+        const seen: string[] = [];
+        await executor.executeToolCalls(
+            [{ id: '1', name: 'a', arguments: '{}' }, { id: '2', name: 'b', arguments: '{}' }],
+            [tool('a', async () => 'a'), tool('b', async () => 'b')],
+            { onResult: (r: ToolCallOutcome) => seen.push(r.id) }
+        );
+
+        expect(seen.slice().sort()).to.deep.equal(['1', '2']);
+    });
+
+    it('forwards the cancellation token into each ToolInvocationContext', async () => {
+        const source = new CancellationTokenSource();
+        let received: CancellationToken | undefined;
+        await executor.executeToolCalls(
+            [{ id: '1', name: 'a', arguments: '{}' }],
+            [tool('a', async (_args, ctx) => { received = ToolInvocationContext.getCancellationToken(ctx); return 'a'; })],
+            { cancellationToken: source.token }
+        );
+
+        expect(received).to.equal(source.token);
+    });
+
+    it('does not let a throwing onResult callback reject the execution or affect the results', async () => {
+        const results = await executor.executeToolCalls(
+            [{ id: '1', name: 'a', arguments: '{}' }, { id: '2', name: 'b', arguments: '{}' }],
+            [tool('a', async () => 'a-done'), tool('b', async () => 'b-done')],
+            { onResult: () => { throw new Error('reporting boom'); } }
+        );
+
+        expect(results.map(r => r.result)).to.deep.equal(['a-done', 'b-done']);
+    });
+
+    it('returns an empty array and never calls onResult for empty input', async () => {
+        let called = false;
+        const results = await executor.executeToolCalls([], [tool('a', async () => 'a')], { onResult: () => { called = true; } });
+        expect(results).to.deep.equal([]);
+        expect(called).to.equal(false);
+    });
+});

package/src/common/tool-call-execution.ts

@@ -0,0 +1,161 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { CancellationToken, ILogger } from '@theia/core';
+import { inject, injectable, named } from '@theia/core/shared/inversify';
+import {
+    ToolRequest,
+    ToolCallResult,
+    ToolInvocationContext,
+    createToolCallError
+} from './language-model';
+
+/**
+ * A single tool call collected from one model response/turn, in a provider-neutral shape.
+ * Each language model normalizes its own representation into this shape before execution.
+ */
+export interface ToolInvocation {
+    /** The tool call ID assigned by the model; forwarded into the {@link ToolInvocationContext}. */
+    readonly id: string;
+    /** The name used to match against {@link ToolRequest.name}. */
+    readonly name: string;
+    /** The raw JSON argument string passed verbatim to {@link ToolRequest.handler}. */
+    readonly arguments: string;
+}
+
+/**
+ * A tool reduced to what executing a call against it requires: the name that a {@link ToolInvocation}
+ * is matched against and the handler to invoke. A language model that has already converted the
+ * request's tools into its provider's own representation can recover just these two from that
+ * representation instead of reconstructing a whole {@link ToolRequest}.
+ */
+export type ExecutableTool = Pick<ToolRequest, 'name' | 'handler'>;
+
+/**
+ * The normalized outcome of executing one tool call. Returned in the same order as the
+ * input array, regardless of the order in which the calls actually completed.
+ */
+export interface ToolCallOutcome {
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: string;
+    /**
+     * The handler result, or a {@link createToolCallError} value if the tool was not found
+     * or the handler threw. A thrown handler yields an error result here, never a rejection.
+     */
+    readonly result: ToolCallResult;
+    /** The original error if the handler threw; `undefined` for success and for tool-not-found. */
+    readonly error?: Error;
+    /** `true` when no {@link ToolRequest} matched {@link ToolInvocation.name}. */
+    readonly notFound: boolean;
+}
+
+export interface ToolCallExecutionOptions {
+    /**
+     * Optional per-call hook invoked exactly once per tool call as soon as that call settles
+     * (success, throw, or not-found). Use it for per-call side effects such as streaming a UI
+     * event or appending a provider message.
+     *
+     * **Note:** because calls run concurrently, this hook fires in completion order, not input
+     * order. Side effects that must be ordered should instead be performed by the caller over
+     * the returned (input-ordered) array of execution results.
+     */
+    readonly onResult?: (result: ToolCallOutcome) => void;
+    /** Optional cancellation token forwarded into each {@link ToolInvocationContext}. */
+    readonly cancellationToken?: CancellationToken;
+}
+
+/**
+ * Executes the tool calls of a single language model response/turn.
+ *
+ * Concurrency contract: tool calls emitted within a single model response/turn are executed
+ * concurrently. All matched handlers are started before any of them is awaited.
+ * A tool handler must therefore not assume that it runs in isolation or in array
+ * order, and must be safe to overlap with sibling calls from the same turn. Models serialize
+ * dependent calls across turns (by withholding a dependent call until it has seen the prior
+ * result), so "issued together in one turn" is the model's signal that the calls are independent.
+ *
+ * Error handling is uniform across all language model providers:
+ *  - If no {@link ToolRequest} matches a call's name, its result is a
+ *    {@link createToolCallError} with kind `'tool-not-available'` and `notFound` is `true`.
+ *  - If a handler throws/rejects, the rejection is caught, logged, and converted to a
+ *    {@link createToolCallError}; the original error is exposed on `error`.
+ *  - The overall tool execution promise never rejects but returns a result that may
+ *    include errors from failed tool calls
+ */
+export interface ToolCallExecutor {
+    /**
+     * Executes all `toolCalls` concurrently and returns their outcomes in input order.
+     *
+     * @param toolCalls the tool calls collected for this turn (id + name + raw args)
+     * @param tools the tools available for this request (typically `request.tools`), reduced to the
+     * {@link ExecutableTool} shape
+     * @param options optional per-call hook and cancellation token
+     */
+    executeToolCalls(
+        toolCalls: readonly ToolInvocation[],
+        tools: readonly ExecutableTool[] | undefined,
+        options?: ToolCallExecutionOptions
+    ): Promise<ToolCallOutcome[]>;
+}
+
+export const ToolCallExecutor = Symbol('ToolCallExecutor');
+
+@injectable()
+export class ToolCallExecutorImpl implements ToolCallExecutor {
+
+    @inject(ILogger) @named('ai-core:ToolCallExecutorImpl')
+    protected readonly logger: ILogger;
+
+    async executeToolCalls(
+        toolCalls: readonly ToolInvocation[],
+        tools: readonly ExecutableTool[] | undefined,
+        options: ToolCallExecutionOptions = {}
+    ): Promise<ToolCallOutcome[]> {
+        return Promise.all(toolCalls.map(toolCall => this.executeToolCall(toolCall, tools, options)));
+    }
+
+    protected async executeToolCall(
+        toolCall: ToolInvocation,
+        tools: readonly ExecutableTool[] | undefined,
+        options: ToolCallExecutionOptions
+    ): Promise<ToolCallOutcome> {
+        const { id, name, arguments: args } = toolCall;
+        const tool = tools?.find(candidate => candidate.name === name);
+        let outcome: ToolCallOutcome;
+        if (!tool) {
+            outcome = {
+                id, name, arguments: args, notFound: true,
+                result: createToolCallError(`Tool '${name}' not found in the available tools for this request.`, 'tool-not-available')
+            };
+        } else {
+            try {
+                const result = await tool.handler(args, ToolInvocationContext.create(id, options.cancellationToken));
+                outcome = { id, name, arguments: args, result, notFound: false };
+            } catch (e) {
+                const error = e instanceof Error ? e : new Error(String(e));
+                this.logger.error(`Error executing tool ${name}:`, e);
+                outcome = { id, name, arguments: args, notFound: false, error, result: createToolCallError(error.message || 'Tool execution failed') };
+            }
+        }
+        try {
+            options.onResult?.(outcome);
+        } catch (error) {
+            this.logger.error('Uncaught error in tool-call onResult call-back.', error);
+        }
+        return outcome;
+    }
+}

package/src/common/tool-request-parameters.spec.ts

@@ -0,0 +1,81 @@
+// *****************************************************************************
+// Copyright (C) 2026 Beijing Kaikong Technology Co., Ltd. and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from 'chai';
+import { ToolRequest } from './language-model';
+
+describe('ToolRequest.isToolRequestParameters', () => {
+    it('accepts a property with a plain string type', () => {
+        expect(
+            ToolRequest.isToolRequestParameters({
+                type: 'object',
+                properties: { name: { type: 'string' } }
+            })
+        ).to.equal(true);
+    });
+
+    it('accepts a property whose type is a union array (JSON Schema 2020-12)', () => {
+        // Mirrors the shape produced by MCP tools with `type: ["string", "null"]`.
+        expect(
+            ToolRequest.isToolRequestParameters({
+                type: 'object',
+                properties: { opt: { type: ['string', 'null'] } }
+            })
+        ).to.equal(true);
+    });
+
+    it('accepts a property whose type array has more than two elements', () => {
+        expect(
+            ToolRequest.isToolRequestParameters({
+                type: 'object',
+                properties: { mixed: { type: ['string', 'number', 'null'] } }
+            })
+        ).to.equal(true);
+    });
+
+    it('rejects a property whose type array contains a non-string element', () => {
+        expect(
+            ToolRequest.isToolRequestParameters({
+                type: 'object',
+                properties: { bad: { type: ['string', 42] } }
+            })
+        ).to.equal(false);
+    });
+
+    it('rejects a property whose type is not a string or an array of strings', () => {
+        expect(
+            ToolRequest.isToolRequestParameters({
+                type: 'object',
+                properties: { bad: { type: 42 } }
+            })
+        ).to.equal(false);
+    });
+
+    it('rejects a property without a type or anyOf', () => {
+        expect(
+            ToolRequest.isToolRequestParameters({
+                type: 'object',
+                properties: { bad: {} }
+            })
+        ).to.equal(false);
+    });
+
+    it('rejects a top-level object without a properties object', () => {
+        expect(
+            ToolRequest.isToolRequestParameters({ type: 'object' })
+        ).to.equal(false);
+    });
+});