@elyracode/web-ui 0.9.10 → 0.9.12

package/src/tools/artifacts/artifacts-tool-renderer.ts

@@ -1,5 +1,5 @@
 import "@elyracode/mini-lit/dist/CodeBlock.js";
-import type { ToolResultMessage } from "@elyracode/ai";
+import type { TextContent, ToolResultMessage } from "@elyracode/ai";
 import { createRef, ref } from "lit/directives/ref.js";
 import { FileCode2 } from "lucide";
 import "../../components/ConsoleBlock.js";
@@ -12,12 +12,12 @@ import { ArtifactPill } from "./ArtifactPill.js";
 import type { ArtifactsPanel, ArtifactsParams } from "./artifacts.js";
 
 // Helper to extract text from content blocks
-function getTextOutput(result: ToolResultMessage<any> | undefined): string {
+function getTextOutput(result: ToolResultMessage<unknown> | undefined): string {
 	if (!result) return "";
 	return (
 		result.content
-			?.filter((c) => c.type === "text")
-			.map((c: any) => c.text)
+			?.filter((c): c is TextContent => c.type === "text")
+			.map((c) => c.text)
 			.join("\n") || ""
 	);
 }

package/src/tools/artifacts/artifacts.ts

@@ -311,7 +311,7 @@ export class ArtifactsPanel extends LitElement {
 		// 2) Build an ordered list of successful artifact operations
 		const operations: Array<ArtifactsParams> = [];
 		for (const m of messages) {
-			if ((m as any).role === "artifact") {
+			if (m.role === "artifact") {
 				const artifactMsg = m as ArtifactMessage;
 				switch (artifactMsg.action) {
 					case "create":
@@ -337,8 +337,8 @@ export class ArtifactsPanel extends LitElement {
 				}
 			}
 			// Handle tool result messages (from artifacts tool calls)
-			else if ((m as any).role === "toolResult" && (m as any).toolName === artifactToolName && !(m as any).isError) {
-				const toolCallId = (m as any).toolCallId as string;
+			else if (m.role === "toolResult" && m.toolName === artifactToolName && !m.isError) {
+				const toolCallId = m.toolCallId;
 				const call = toolCalls.get(toolCallId);
 				if (!call) continue;
 				const params = call.arguments as ArtifactsParams;
@@ -431,7 +431,7 @@ export class ArtifactsPanel extends LitElement {
 				return this.getLogs(params);
 			default:
 				// Should never happen with TypeBox validation
-				return `Error: Unknown command ${(params as any).command}`;
+				return `Error: Unknown command ${(params as { command: string }).command}`;
 		}
 	}
 

package/src/tools/extract-document.ts

@@ -1,5 +1,5 @@
 import type { AgentTool } from "@elyracode/agent-core";
-import type { ToolResultMessage } from "@elyracode/ai";
+import type { TextContent, ToolResultMessage } from "@elyracode/ai";
 import { html } from "lit";
 import { createRef, ref } from "lit/directives/ref.js";
 import { FileText } from "lucide";
@@ -103,17 +103,17 @@ export function createExtractDocumentTool(): AgentTool<typeof extractDocumentSch
 			try {
 				// Attempt direct fetch first
 				arrayBuffer = await fetchAndProcess(url);
-			} catch (directError: any) {
+			} catch (directError) {
 				// If CORS error and proxy is available, retry with proxy
 				if (isCorsError(directError) && tool.corsProxyUrl) {
 					try {
 						const proxiedUrl = tool.corsProxyUrl + encodeURIComponent(url);
 						arrayBuffer = await fetchAndProcess(proxiedUrl);
-					} catch (proxyError: any) {
+					} catch (proxyError) {
 						// Proxy fetch also failed - throw helpful message
 						throw new Error(
 							`TELL USER: Unable to fetch the document due to CORS restrictions.\n\n` +
-								`Tried with proxy but it also failed: ${proxyError.message}\n\n` +
+								`Tried with proxy but it also failed: ${proxyError instanceof Error ? proxyError.message : String(proxyError)}\n\n` +
 								`INSTRUCT USER: Please download the file manually and attach it to your message using the attachment button (paperclip icon) in the message input area. I can then extract the text from the attached file.`,
 						);
 					}
@@ -213,8 +213,8 @@ export const extractDocumentRenderer: ToolRenderer<ExtractDocumentParams, Extrac
 
 			const output =
 				result.content
-					?.filter((c) => c.type === "text")
-					.map((c: any) => c.text)
+					?.filter((c): c is TextContent => c.type === "text")
+					.map((c) => c.text)
 					.join("\n") || "";
 
 			return {

package/src/tools/index.ts

@@ -27,7 +27,7 @@ export function setShowJsonMode(enabled: boolean): void {
  */
 export function renderTool(
 	toolName: string,
-	params: any | undefined,
+	params: unknown | undefined,
 	result: ToolResultMessage | undefined,
 	isStreaming?: boolean,
 ): ToolRenderResult {

package/src/tools/javascript-repl.ts

@@ -1,5 +1,5 @@
 import type { AgentTool } from "@elyracode/agent-core";
-import type { ToolResultMessage } from "@elyracode/ai";
+import type { TextContent, ToolResultMessage } from "@elyracode/ai";
 import { i18n } from "@elyracode/mini-lit";
 import { html } from "lit";
 import { createRef, ref } from "lit/directives/ref.js";
@@ -214,8 +214,8 @@ export const javascriptReplRenderer: ToolRenderer<JavaScriptReplParams, JavaScri
 		if (result && params) {
 			const output =
 				result.content
-					?.filter((c) => c.type === "text")
-					.map((c: any) => c.text)
+					?.filter((c): c is TextContent => c.type === "text")
+					.map((c) => c.text)
 					.join("\n") || "";
 			const files = result.details?.files || [];
 

package/src/tools/renderer-registry.ts

@@ -2,7 +2,7 @@ import { icon } from "@elyracode/mini-lit";
 import { html, type TemplateResult } from "lit";
 import type { Ref } from "lit/directives/ref.js";
 import { ref } from "lit/directives/ref.js";
-import { ChevronsUpDown, ChevronUp, Loader } from "lucide";
+import { ChevronsUpDown, ChevronUp, type IconNode, Loader } from "lucide";
 import type { ToolRenderer } from "./types.js";
 
 // Registry of tool renderers
@@ -28,10 +28,10 @@ export function getToolRenderer(toolName: string): ToolRenderer | undefined {
  */
 export function renderHeader(
 	state: "inprogress" | "complete" | "error",
-	toolIcon: any,
+	toolIcon: IconNode,
 	text: string | TemplateResult,
 ): TemplateResult {
-	const statusIcon = (iconComponent: any, color: string) =>
+	const statusIcon = (iconComponent: IconNode, color: string) =>
 		html`<span class="inline-block ${color}">${icon(iconComponent, "sm")}</span>`;
 
 	switch (state) {
@@ -68,13 +68,13 @@ export function renderHeader(
  */
 export function renderCollapsibleHeader(
 	state: "inprogress" | "complete" | "error",
-	toolIcon: any,
+	toolIcon: IconNode,
 	text: string | TemplateResult,
 	contentRef: Ref<HTMLElement>,
 	chevronRef: Ref<HTMLElement>,
 	defaultExpanded = false,
 ): TemplateResult {
-	const statusIcon = (iconComponent: any, color: string) =>
+	const statusIcon = (iconComponent: IconNode, color: string) =>
 		html`<span class="inline-block ${color}">${icon(iconComponent, "sm")}</span>`;
 
 	const toggleContent = (e: Event) => {

package/src/tools/renderers/BashRenderer.ts

@@ -1,4 +1,4 @@
-import type { ToolResultMessage } from "@elyracode/ai";
+import type { TextContent, ToolResultMessage } from "@elyracode/ai";
 import { html } from "lit";
 import { SquareTerminal } from "lucide";
 import { i18n } from "../../utils/i18n.js";
@@ -18,8 +18,8 @@ export class BashRenderer implements ToolRenderer<BashParams, undefined> {
 		if (result && params?.command) {
 			const output =
 				result.content
-					?.filter((c) => c.type === "text")
-					.map((c: any) => c.text)
+					?.filter((c): c is TextContent => c.type === "text")
+					.map((c) => c.text)
 					.join("\n") || "";
 			const combined = output ? `> ${params.command}\n\n${output}` : `> ${params.command}`;
 			return {

package/src/tools/renderers/CalculateRenderer.ts

@@ -1,4 +1,4 @@
-import type { ToolResultMessage } from "@elyracode/ai";
+import type { TextContent, ToolResultMessage } from "@elyracode/ai";
 import { html } from "lit";
 import { Calculator } from "lucide";
 import { i18n } from "../../utils/i18n.js";
@@ -18,8 +18,8 @@ export class CalculateRenderer implements ToolRenderer<CalculateParams, undefine
 		if (result && params?.expression) {
 			const output =
 				result.content
-					?.filter((c) => c.type === "text")
-					.map((c: any) => c.text)
+					?.filter((c): c is TextContent => c.type === "text")
+					.map((c) => c.text)
 					.join("\n") || "";
 
 			// Error: show expression in header, error below

package/src/tools/renderers/DefaultRenderer.ts

@@ -1,4 +1,4 @@
-import type { ToolResultMessage } from "@elyracode/ai";
+import type { TextContent, ToolResultMessage } from "@elyracode/ai";
 import { html } from "lit";
 import { Code } from "lucide";
 import { i18n } from "../../utils/i18n.js";
@@ -6,14 +6,14 @@ import { renderHeader } from "../renderer-registry.js";
 import type { ToolRenderer, ToolRenderResult } from "../types.js";
 
 export class DefaultRenderer implements ToolRenderer {
-	render(params: any | undefined, result: ToolResultMessage | undefined, isStreaming?: boolean): ToolRenderResult {
+	render(params: unknown | undefined, result: ToolResultMessage | undefined, isStreaming?: boolean): ToolRenderResult {
 		const state = result ? (result.isError ? "error" : "complete") : isStreaming ? "inprogress" : "complete";
 
 		// Format params as JSON
 		let paramsJson = "";
 		if (params) {
 			try {
-				paramsJson = JSON.stringify(JSON.parse(params), null, 2);
+				paramsJson = JSON.stringify(JSON.parse(params as string), null, 2);
 			} catch {
 				try {
 					paramsJson = JSON.stringify(params, null, 2);
@@ -27,8 +27,8 @@ export class DefaultRenderer implements ToolRenderer {
 		if (result) {
 			let outputJson =
 				result.content
-					?.filter((c) => c.type === "text")
-					.map((c: any) => c.text)
+					?.filter((c): c is TextContent => c.type === "text")
+					.map((c) => c.text)
 					.join("\n") || i18n("(no output)");
 			let outputLanguage = "text";
 

package/src/tools/renderers/GetCurrentTimeRenderer.ts

@@ -1,4 +1,4 @@
-import type { ToolResultMessage } from "@elyracode/ai";
+import type { TextContent, ToolResultMessage } from "@elyracode/ai";
 import { html } from "lit";
 import { Clock } from "lucide";
 import { i18n } from "../../utils/i18n.js";
@@ -21,8 +21,8 @@ export class GetCurrentTimeRenderer implements ToolRenderer<GetCurrentTimeParams
 		if (result && params) {
 			const output =
 				result.content
-					?.filter((c) => c.type === "text")
-					.map((c: any) => c.text)
+					?.filter((c): c is TextContent => c.type === "text")
+					.map((c) => c.text)
 					.join("\n") || "";
 			const headerText = params.timezone
 				? `${i18n("Getting current time in")} ${params.timezone}`
@@ -49,8 +49,8 @@ export class GetCurrentTimeRenderer implements ToolRenderer<GetCurrentTimeParams
 		if (result) {
 			const output =
 				result.content
-					?.filter((c) => c.type === "text")
-					.map((c: any) => c.text)
+					?.filter((c): c is TextContent => c.type === "text")
+					.map((c) => c.text)
 					.join("\n") || "";
 
 			// Error: show header, error below

package/src/tools/types.ts

@@ -6,7 +6,7 @@ export interface ToolRenderResult {
 	isCustom: boolean; // true = no card wrapper, false = wrap in card
 }
 
-export interface ToolRenderer<TParams = any, TDetails = any> {
+export interface ToolRenderer<TParams = unknown, TDetails = unknown> {
 	render(
 		params: TParams | undefined,
 		result: ToolResultMessage<TDetails> | undefined,

package/src/utils/attachment-utils.ts

@@ -214,8 +214,8 @@ async function processPdf(
 			const page = await pdf.getPage(i);
 			const textContent = await page.getTextContent();
 			const pageText = textContent.items
-				.map((item: any) => item.str)
-				.filter((str: string) => str.trim())
+				.map((item) => ("str" in item ? item.str : ""))
+				.filter((str) => str.trim())
 				.join(" ");
 			extractedText += `\n<page number="${i}">\n${pageText}\n</page>`;
 		}
@@ -298,7 +298,14 @@ async function processDocx(arrayBuffer: ArrayBuffer, fileName: string): Promise<
 	}
 }
 
-function extractTextFromElement(element: any): string {
+/** Structural shape of a docx-preview document tree node (the library types its tree as `any`). */
+interface DocxElement {
+	type?: string;
+	text?: string;
+	children?: DocxElement[];
+}
+
+function extractTextFromElement(element: DocxElement): string {
 	let text = "";
 
 	// Check type with lowercase

package/src/utils/format.ts

@@ -1,11 +1,11 @@
-import type { Usage } from "@elyracode/ai";
+import type { Api, Model, Usage } from "@elyracode/ai";
 import { i18n } from "@elyracode/mini-lit";
 
 export function formatCost(cost: number): string {
 	return `$${cost.toFixed(4)}`;
 }
 
-export function formatModelCost(cost: any): string {
+export function formatModelCost(cost: Model<Api>["cost"] | undefined): string {
 	if (!cost) return i18n("Free");
 	const input = cost.input || 0;
 	const output = cost.output || 0;

package/src/utils/model-discovery.ts

@@ -1,14 +1,27 @@
-import type { Model } from "@elyracode/ai";
+import type { Api, Model } from "@elyracode/ai";
 import { LMStudioClient } from "@lmstudio/sdk";
 import { Ollama } from "ollama/browser";
 
+/** Minimal shape of a model entry from an OpenAI-compatible /v1/models endpoint. */
+interface OpenAICompatibleModel {
+	id: string;
+	context_length?: number;
+	max_tokens?: number;
+	max_model_len?: number;
+}
+
+/** Minimal shape of the response from an OpenAI-compatible /v1/models endpoint. */
+interface OpenAICompatibleModelsResponse {
+	data?: OpenAICompatibleModel[];
+}
+
 /**
  * Discover models from an Ollama server.
  * @param baseUrl - Base URL of the Ollama server (e.g., "http://localhost:11434")
  * @param apiKey - Optional API key (currently unused by Ollama)
  * @returns Array of discovered models
  */
-export async function discoverOllamaModels(baseUrl: string, _apiKey?: string): Promise<Model<any>[]> {
+export async function discoverOllamaModels(baseUrl: string, _apiKey?: string): Promise<Model<Api>[]> {
 	try {
 		// Create Ollama client
 		const ollama = new Ollama({ host: baseUrl });
@@ -17,7 +30,7 @@ export async function discoverOllamaModels(baseUrl: string, _apiKey?: string): P
 		const { models } = await ollama.list();
 
 		// Fetch details for each model and convert to Model format
-		const ollamaModelPromises: Promise<Model<any> | null>[] = models.map(async (model: any) => {
+		const ollamaModelPromises: Promise<Model<Api> | null>[] = models.map(async (model) => {
 			try {
 				// Get model details
 				const details = await ollama.show({
@@ -25,14 +38,14 @@ export async function discoverOllamaModels(baseUrl: string, _apiKey?: string): P
 				});
 
 				// Check capabilities - filter out models that don't support tools
-				const capabilities: string[] = (details as any).capabilities || [];
+				const capabilities: string[] = details.capabilities || [];
 				if (!capabilities.includes("tools")) {
 					console.debug(`Skipping model ${model.name}: does not support tools`);
 					return null;
 				}
 
 				// Extract model info
-				const modelInfo: any = details.model_info || {};
+				const modelInfo = (details.model_info || {}) as unknown as Record<string, string>;
 
 				// Get context window size - look for architecture-specific keys
 				const architecture = modelInfo["general.architecture"] || "";
@@ -43,10 +56,10 @@ export async function discoverOllamaModels(baseUrl: string, _apiKey?: string): P
 				const maxTokens = contextWindow * 10;
 
 				// Ollama only supports completions API
-				const ollamaModel: Model<any> = {
+				const ollamaModel: Model<Api> = {
 					id: model.name,
 					name: model.name,
-					api: "openai-completions" as any,
+					api: "openai-completions",
 					provider: "", // Will be set by caller
 					baseUrl: `${baseUrl}/v1`,
 					reasoning: capabilities.includes("thinking"),
@@ -69,7 +82,7 @@ export async function discoverOllamaModels(baseUrl: string, _apiKey?: string): P
 		});
 
 		const results = await Promise.all(ollamaModelPromises);
-		return results.filter((m): m is Model<any> => m !== null);
+		return results.filter((m): m is Model<Api> => m !== null);
 	} catch (err) {
 		console.error("Failed to discover Ollama models:", err);
 		throw new Error(`Ollama discovery failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -82,7 +95,7 @@ export async function discoverOllamaModels(baseUrl: string, _apiKey?: string): P
  * @param apiKey - Optional API key
  * @returns Array of discovered models
  */
-export async function discoverLlamaCppModels(baseUrl: string, apiKey?: string): Promise<Model<any>[]> {
+export async function discoverLlamaCppModels(baseUrl: string, apiKey?: string): Promise<Model<Api>[]> {
 	try {
 		const headers: HeadersInit = {
 			"Content-Type": "application/json",
@@ -101,21 +114,21 @@ export async function discoverLlamaCppModels(baseUrl: string, apiKey?: string):
 			throw new Error(`HTTP ${response.status}: ${response.statusText}`);
 		}
 
-		const data = await response.json();
+		const data = (await response.json()) as OpenAICompatibleModelsResponse;
 
 		if (!data.data || !Array.isArray(data.data)) {
 			throw new Error("Invalid response format from llama.cpp server");
 		}
 
-		return data.data.map((model: any) => {
+		return data.data.map((model) => {
 			// llama.cpp doesn't always provide context window info
 			const contextWindow = model.context_length || 8192;
 			const maxTokens = model.max_tokens || 4096;
 
-			const llamaModel: Model<any> = {
+			const llamaModel: Model<Api> = {
 				id: model.id,
 				name: model.id,
-				api: "openai-completions" as any,
+				api: "openai-completions",
 				provider: "", // Will be set by caller
 				baseUrl: `${baseUrl}/v1`,
 				reasoning: false,
@@ -144,7 +157,7 @@ export async function discoverLlamaCppModels(baseUrl: string, apiKey?: string):
  * @param apiKey - Optional API key
  * @returns Array of discovered models
  */
-export async function discoverVLLMModels(baseUrl: string, apiKey?: string): Promise<Model<any>[]> {
+export async function discoverVLLMModels(baseUrl: string, apiKey?: string): Promise<Model<Api>[]> {
 	try {
 		const headers: HeadersInit = {
 			"Content-Type": "application/json",
@@ -163,21 +176,21 @@ export async function discoverVLLMModels(baseUrl: string, apiKey?: string): Prom
 			throw new Error(`HTTP ${response.status}: ${response.statusText}`);
 		}
 
-		const data = await response.json();
+		const data = (await response.json()) as OpenAICompatibleModelsResponse;
 
 		if (!data.data || !Array.isArray(data.data)) {
 			throw new Error("Invalid response format from vLLM server");
 		}
 
-		return data.data.map((model: any) => {
+		return data.data.map((model) => {
 			// vLLM provides max_model_len which is the context window
 			const contextWindow = model.max_model_len || 8192;
 			const maxTokens = Math.min(contextWindow, 4096); // Cap max tokens
 
-			const vllmModel: Model<any> = {
+			const vllmModel: Model<Api> = {
 				id: model.id,
 				name: model.id,
-				api: "openai-completions" as any,
+				api: "openai-completions",
 				provider: "", // Will be set by caller
 				baseUrl: `${baseUrl}/v1`,
 				reasoning: false,
@@ -206,7 +219,7 @@ export async function discoverVLLMModels(baseUrl: string, apiKey?: string): Prom
  * @param apiKey - Optional API key (unused for LM Studio SDK)
  * @returns Array of discovered models
  */
-export async function discoverLMStudioModels(baseUrl: string, _apiKey?: string): Promise<Model<any>[]> {
+export async function discoverLMStudioModels(baseUrl: string, _apiKey?: string): Promise<Model<Api>[]> {
 	try {
 		// Extract host and port from baseUrl
 		const url = new URL(baseUrl);
@@ -226,10 +239,10 @@ export async function discoverLMStudioModels(baseUrl: string, _apiKey?: string):
 				// Use 10x context length like Ollama does
 				const maxTokens = contextWindow;
 
-				const lmStudioModel: Model<any> = {
+				const lmStudioModel: Model<Api> = {
 					id: model.path,
 					name: model.displayName || model.path,
-					api: "openai-completions" as any,
+					api: "openai-completions",
 					provider: "", // Will be set by caller
 					baseUrl: `${baseUrl}/v1`,
 					reasoning: model.trainedForToolUse || false,
@@ -263,7 +276,7 @@ export async function discoverModels(
 	type: "ollama" | "llama.cpp" | "vllm" | "lmstudio",
 	baseUrl: string,
 	apiKey?: string,
-): Promise<Model<any>[]> {
+): Promise<Model<Api>[]> {
 	switch (type) {
 		case "ollama":
 			return discoverOllamaModels(baseUrl, apiKey);

package/src/utils/proxy-utils.ts

@@ -125,7 +125,7 @@ export function isCorsError(error: unknown): boolean {
  * @returns A streamFn compatible with Agent's streamFn option
  */
 export function createStreamFn(getProxyUrl: () => Promise<string | undefined>) {
-	return async (model: Model<any>, context: Context, options?: SimpleStreamOptions) => {
+	return async (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => {
 		const apiKey = options?.apiKey;
 		const proxyUrl = await getProxyUrl();