@theia/ai-chat 1.72.0-next.59 → 1.72.0

package/src/common/chat-response-model.spec.ts

@@ -15,9 +15,28 @@
 // *****************************************************************************
 
 import { expect } from 'chai';
-import { MutableChatResponseModel } from './chat-model';
+import { MutableChatResponseModel, ToolCallChatResponseContentImpl } from './chat-model';
 
 describe('MutableChatResponseModel', () => {
+    describe('content change propagation', () => {
+        it('should fire onDidChange when a tool call\'s result is updated after it was added', () => {
+            const response = new MutableChatResponseModel('req-1');
+            const toolCall = new ToolCallChatResponseContentImpl('tool-1', 'tool', '{}', false);
+            response.response.addContent(toolCall);
+
+            let fireCount = 0;
+            response.onDidChange(() => { fireCount++; });
+
+            toolCall.updateResult('partial');
+
+            // The response model must observe the change so auto-save can persist
+            // intermediate state. Without this propagation, mutations that don't go
+            // through addContent/merge (e.g. renderer-side partial results) would be
+            // lost on reload.
+            expect(fireCount).to.equal(1);
+        });
+    });
+
     describe('setTokenUsage', () => {
         it('should also add a token usage entry', () => {
             const response = new MutableChatResponseModel('req-1');

package/src/common/chat-service.ts

@@ -455,9 +455,11 @@ export class ChatServiceImpl implements ChatService {
             return Promise.resolve();
         }
 
-        // Store session with title and pinned agent info
+        // Store session with title, pinned agent info, last interaction timestamp, and error state
+        const lastRequest = session.model.getRequests().at(-1);
+        const hasError = lastRequest?.response.isComplete === true && lastRequest?.response.isError === true;
         return this.sessionStore.storeSessions(
-            { model: session.model, title: session.title, pinnedAgentId: session.pinnedAgent?.id }
+            { model: session.model, title: session.title, pinnedAgentId: session.pinnedAgent?.id, lastInteraction: session.lastInteraction?.getTime(), hasError }
         ).catch(error => {
             this.logger.error('Failed to store chat sessions', error);
         });

package/src/common/chat-session-store.ts

@@ -24,6 +24,10 @@ export interface ChatModelWithMetadata {
     model: ChatModel;
     title?: string;
     pinnedAgentId?: string;
+    /** Timestamp (ms since epoch) of the last user interaction. Used as the display date for session cards. */
+    lastInteraction?: number;
+    /** Whether the last request ended with an error. */
+    hasError?: boolean;
 }
 
 export interface ChatSessionStore {
@@ -67,4 +71,8 @@ export interface ChatSessionMetadata {
     title: string;
     saveDate: number;
     location: ChatAgentLocation;
+    /** ID of the agent pinned to the session (used for icon and display name on cards). */
+    pinnedAgentId?: string;
+    /** Whether the last request ended with an error. */
+    hasError?: boolean;
 }

package/src/common/index.ts

@@ -28,3 +28,4 @@ export * from './parsed-chat-request';
 export * from './context-variables';
 export * from './chat-tool-request-service';
 export * from './chat-tool-confirmation-timeout';
+export * from './provider-error-formatter';

package/src/common/provider-error-formatter.spec.ts

@@ -0,0 +1,190 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource 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 { formatProviderError, formattedProviderErrorToShortString } from './provider-error-formatter';
+
+describe('formatProviderError', () => {
+
+    it('should handle undefined input', () => {
+        const result = formatProviderError(undefined);
+        expect(result.message).to.equal('');
+        expect(result.status).to.be.undefined;
+        expect(result.details).to.be.undefined;
+        expect(result.raw).to.equal('');
+    });
+
+    it('should handle empty string input', () => {
+        const result = formatProviderError('');
+        expect(result.message).to.equal('');
+        expect(result.status).to.be.undefined;
+        expect(result.details).to.be.undefined;
+        expect(result.raw).to.equal('');
+    });
+
+    it('should handle plain text error without JSON', () => {
+        const result = formatProviderError('Something went wrong');
+        expect(result.message).to.equal('Something went wrong');
+        expect(result.status).to.be.undefined;
+        expect(result.details).to.be.undefined;
+        expect(result.raw).to.equal('Something went wrong');
+    });
+
+    it('should extract HTTP status from leading prefix', () => {
+        const raw = '401 {"error":{"message":"Invalid API key","type":"auth_error"}}';
+        const result = formatProviderError(raw);
+        expect(result.status).to.equal('401');
+        expect(result.message).to.equal('Invalid API key');
+        expect(result.details).to.be.a('string');
+        expect(result.raw).to.equal(raw);
+    });
+
+    it('should extract status from JSON code field when no leading prefix', () => {
+        const raw = '{"error":{"message":"Permission denied","code":403}}';
+        const result = formatProviderError(raw);
+        expect(result.status).to.equal('403');
+        expect(result.message).to.equal('Permission denied');
+    });
+
+    it('should extract status from JSON status field', () => {
+        const raw = '{"error":{"message":"Not found","status":404}}';
+        const result = formatProviderError(raw);
+        expect(result.status).to.equal('404');
+        expect(result.message).to.equal('Not found');
+    });
+
+    it('should prefer leading HTTP status over JSON code field', () => {
+        const raw = '500 {"error":{"message":"Server error","code":503}}';
+        const result = formatProviderError(raw);
+        expect(result.status).to.equal('500');
+        expect(result.message).to.equal('Server error');
+    });
+
+    it('should extract the deepest message from nested JSON', () => {
+        const raw = '400 {"error":{"message":"Top level","details":{"message":"Deeper reason"}}}';
+        const result = formatProviderError(raw);
+        expect(result.status).to.equal('400');
+        expect(result.message).to.equal('Deeper reason');
+    });
+
+    it('should handle Gemini-style errors with JSON-encoded inner body', () => {
+        const inner = JSON.stringify({ error: { message: 'API key not valid', status: 'INVALID_ARGUMENT' } });
+        const raw = `{"error":{"message":${JSON.stringify(inner)},"code":400}}`;
+        const result = formatProviderError(raw);
+        expect(result.status).to.equal('400');
+        expect(result.message).to.equal('API key not valid');
+    });
+
+    it('should fall back to remainder when JSON has no message field', () => {
+        const raw = '429 {"error":{"type":"rate_limit"}}';
+        const result = formatProviderError(raw);
+        expect(result.status).to.equal('429');
+        expect(result.message).to.equal('{"error":{"type":"rate_limit"}}');
+    });
+
+    it('should not treat a leading 3-digit prefix as a status when no JSON body follows', () => {
+        // Avoid misreading arbitrary text that happens to start with 3 digits.
+        const raw = '404 routes were processed';
+        const result = formatProviderError(raw);
+        expect(result.status).to.be.undefined;
+        expect(result.message).to.equal('404 routes were processed');
+        expect(result.details).to.be.undefined;
+    });
+
+    it('should produce unwrapped details for nested JSON strings', () => {
+        const inner = JSON.stringify({ reason: 'quota exceeded' });
+        const raw = `{"error":{"message":"Rate limited","body":${JSON.stringify(inner)}}}`;
+        const result = formatProviderError(raw);
+        expect(result.details).to.be.a('string');
+        // The details should contain the unwrapped inner object, not the escaped JSON string
+        const parsed = JSON.parse(result.details!);
+        expect(parsed.error.body).to.deep.equal({ reason: 'quota exceeded' });
+    });
+
+    it('should not treat a message that looks like JSON as the headline', () => {
+        const raw = '{"error":{"message":"{\\"key\\":\\"value\\"}","code":400}}';
+        const result = formatProviderError(raw);
+        // The JSON-like message should be skipped; headline falls back to remainder
+        expect(result.message).to.equal('{"error":{"message":"{\\"key\\":\\"value\\"}","code":400}}');
+    });
+
+    it('should handle leading status with colon separator', () => {
+        const raw = '401: {"error":{"message":"Unauthorized"}}';
+        const result = formatProviderError(raw);
+        expect(result.status).to.equal('401');
+        expect(result.message).to.equal('Unauthorized');
+    });
+
+    it('should extract message from an array of errors', () => {
+        const raw = '{"errors":[{"message":"Rate limit exceeded","code":429}]}';
+        const result = formatProviderError(raw);
+        expect(result.status).to.equal('429');
+        expect(result.message).to.equal('Rate limit exceeded');
+    });
+
+    it('should ignore non-3-digit numeric codes', () => {
+        const raw = '{"error":{"message":"Something broke","code":42}}';
+        const result = formatProviderError(raw);
+        expect(result.status).to.be.undefined;
+        expect(result.message).to.equal('Something broke');
+    });
+
+    it('should ignore non-numeric status strings', () => {
+        const raw = '{"error":{"message":"Invalid key","status":"INVALID_ARGUMENT"}}';
+        const result = formatProviderError(raw);
+        expect(result.status).to.be.undefined;
+        expect(result.message).to.equal('Invalid key');
+    });
+
+    it('should find JSON preceded by non-JSON text', () => {
+        const raw = 'Error occurred: {"error":{"message":"connection refused"}}';
+        const result = formatProviderError(raw);
+        expect(result.message).to.equal('connection refused');
+        expect(result.details).to.be.a('string');
+    });
+
+    it('should handle whitespace-only input', () => {
+        const result = formatProviderError('   ');
+        expect(result.message).to.equal('   ');
+        expect(result.status).to.be.undefined;
+    });
+
+    it('should walk into a top-level JSON array', () => {
+        const raw = '[{"error":{"message":"first"}},{"error":{"message":"second"}}]';
+        const result = formatProviderError(raw);
+        // walk visits in order, last message wins
+        expect(result.message).to.equal('second');
+    });
+
+    it('should extract 3-digit status from a longer string value', () => {
+        const raw = '{"error":{"message":"Too many requests","status":"429 RESOURCE_EXHAUSTED"}}';
+        const result = formatProviderError(raw);
+        expect(result.status).to.equal('429');
+    });
+});
+
+describe('formattedProviderErrorToShortString', () => {
+
+    it('should include status when present', () => {
+        const result = formattedProviderErrorToShortString({ status: '401', message: 'Invalid API key', raw: '' });
+        expect(result).to.equal('401: Invalid API key');
+    });
+
+    it('should return only headline when no status', () => {
+        const result = formattedProviderErrorToShortString({ message: 'Something went wrong', raw: '' });
+        expect(result).to.equal('Something went wrong');
+    });
+});

package/src/common/provider-error-formatter.ts

@@ -0,0 +1,110 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+
+/**
+ * Structured form of a provider error string. Provider errors look something
+ * like `<httpStatus> <jsonBody>` (Anthropic, OpenAI) or `<jsonBody>` (Gemini).
+ * This helper makes a best-effort guess: walk the JSON, grab the deepest
+ * `message` string and the first 3-digit `code`/`status` field.
+ */
+export interface FormattedProviderError {
+    status?: string;
+    message: string;
+    details?: string;
+    raw: string;
+}
+
+export function formatProviderError(raw: string | undefined): FormattedProviderError {
+    const safeRaw = (raw ?? '').toString();
+    const trimmed = safeRaw.trim();
+    if (!trimmed) { return { message: safeRaw, raw: safeRaw }; }
+
+    // Optional leading HTTP status followed by a JSON body, e.g. "401 {...}".
+    // The JSON-body anchor avoids misreading arbitrary text that happens to
+    // start with 3 digits (e.g. "404 routes were processed") as a status.
+    // Real provider errors (Anthropic, OpenAI) always carry a JSON body here.
+    const match = trimmed.match(/^(\d{3})\b[\s:-]*(?=[{[])/);
+    const remainder = match ? trimmed.slice(match[0].length).trim() : trimmed;
+
+    const body = parseJson(remainder);
+    if (!body || typeof body !== 'object') {
+        return { status: match?.[1], message: remainder || safeRaw, raw: safeRaw };
+    }
+
+    let message: string | undefined;
+    let code: string | undefined;
+    const walk = (node: unknown): void => {
+        if (typeof node === 'string') {
+            const inner = parseJson(node);
+            if (inner && typeof inner === 'object') { walk(inner); }
+            return;
+        }
+        if (!node || typeof node !== 'object') { return; }
+        for (const [k, v] of Object.entries(node)) {
+            if (k === 'message' && typeof v === 'string' && !looksLikeJson(v)) {
+                message = v;
+            } else if (!code && (k === 'code' || k === 'status')) {
+                code = asStatus(v);
+            }
+            walk(v);
+        }
+    };
+    walk(body);
+
+    return {
+        status: match?.[1] ?? code,
+        message: message ?? remainder,
+        details: stringifyUnwrapped(body),
+        raw: safeRaw
+    };
+}
+
+/** Compact one-liner suitable for notification toasts. */
+export function formattedProviderErrorToShortString(e: FormattedProviderError): string {
+    return e.status ? `${e.status}: ${e.message}` : e.message;
+}
+
+function parseJson(text: string): unknown {
+    const start = text.search(/[{[]/);
+    if (start < 0) { return undefined; }
+    try { return JSON.parse(text.slice(start)); } catch { return undefined; }
+}
+
+function looksLikeJson(text: string): boolean {
+    const t = text.trimStart();
+    return t.startsWith('{') || t.startsWith('[');
+}
+
+function asStatus(value: unknown): string | undefined {
+    if (typeof value === 'number' && Number.isInteger(value)) {
+        const s = String(value);
+        return /^\d{3}$/.test(s) ? s : undefined;
+    }
+    return typeof value === 'string' ? value.match(/^(\d{3})\b/)?.[1] : undefined;
+}
+
+/** Pretty-print JSON, transparently parsing any string field that itself contains JSON. */
+function stringifyUnwrapped(value: unknown): string | undefined {
+    try {
+        return JSON.stringify(value, (_, v) => {
+            if (typeof v === 'string' && looksLikeJson(v)) {
+                const inner = parseJson(v);
+                if (inner && typeof inner === 'object') { return inner; }
+            }
+            return v;
+        }, 2);
+    } catch { return undefined; }
+}

package/src/common/tool-call-response-content.spec.ts

@@ -145,6 +145,29 @@ describe('ToolCallChatResponseContentImpl', () => {
         });
     });
 
+    describe('updateResult', () => {
+        it('should set the result without marking the tool finished', () => {
+            const toolCall = new ToolCallChatResponseContentImpl('id', 'tool', '{}', false);
+
+            toolCall.updateResult('partial');
+
+            expect(toolCall.result).to.equal('partial');
+            expect(toolCall.finished).to.be.false;
+        });
+
+        it('should fire onDidChange so auto-save picks up the partial result', () => {
+            const toolCall = new ToolCallChatResponseContentImpl('id', 'tool', '{}', false);
+            let fireCount = 0;
+            toolCall.onDidChange(() => { fireCount++; });
+
+            toolCall.updateResult('partial-1');
+            toolCall.updateResult('partial-2');
+
+            expect(fireCount).to.equal(2);
+            expect(toolCall.result).to.equal('partial-2');
+        });
+    });
+
     describe('restored tool calls', () => {
         it('should have finished=true when restored with a result', () => {
             const restoredToolCall = new ToolCallChatResponseContentImpl(