@shareai-lab/kode 1.0.81 → 1.0.82

package/README.md

@@ -1,11 +1,30 @@
 # Kode - AI Assistant for Your Terminal
 
 [![npm version](https://badge.fury.io/js/@shareai-lab%2Fkode.svg)](https://www.npmjs.com/package/@shareai-lab/kode)
-[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![AGENTS.md](https://img.shields.io/badge/AGENTS.md-Compatible-brightgreen)](https://agents.md)
 
 [中文文档](README.zh-CN.md) | [Contributing](CONTRIBUTING.md) | [Documentation](docs/)
 
+## 🎉 Big Announcement: We're Now Apache 2.0 Licensed!
+
+**Great news for the developer community!** In our commitment to democratizing AI agent technology and fostering a vibrant ecosystem of innovation, we're thrilled to announce that Kode has transitioned from AGPLv3 to the **Apache 2.0 license**.
+
+### What This Means for You:
+- ✅ **Complete Freedom**: Use Kode in any project - personal, commercial, or enterprise
+- ✅ **Build Without Barriers**: Create proprietary solutions without open-sourcing requirements
+- ✅ **Simple Attribution**: Just maintain copyright notices and license info
+- ✅ **Join a Movement**: Be part of accelerating the world's transition to AI-powered development
+
+This change reflects our belief that the future of software development is collaborative, open, and augmented by AI. By removing licensing barriers, we're empowering developers worldwide to build the next generation of AI-assisted tools and workflows. Let's build the future together! 🚀
+
+## 📢 Update Log
+
+**2025-08-29**: We've added Windows support! All Windows users can now run Kode using Git Bash, Unix subsystems, or WSL (Windows Subsystem for Linux) on their computers.
+
+
+<img width="606" height="303" alt="image" src="https://github.com/user-attachments/assets/6cf50553-aacd-4241-a579-6e935b6c62b5" />
+
 ## 🤝 AGENTS.md Standard Support
 
 **Kode proudly supports the [AGENTS.md standard protocol](https://agents.md) initiated by OpenAI** - a simple, open format for guiding programming agents that's used by 20k+ open source projects.
@@ -27,6 +46,8 @@ Kode is a powerful AI assistant that lives in your terminal. It can understand y
 > 
 > **📊 Model Performance**: For optimal performance, we recommend using newer, more capable models designed for autonomous task completion. Avoid older Q&A-focused models like GPT-4o or Gemini 2.5 Pro, which are optimized for answering questions rather than sustained independent task execution. Choose models specifically trained for agentic workflows and extended reasoning capabilities.
 
+<img width="600" height="577" alt="image" src="https://github.com/user-attachments/assets/8b46a39d-1ab6-4669-9391-14ccc6c5234c" />
+
 ## Features
 
 ### Core Capabilities
@@ -390,7 +411,7 @@ We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) f
 
 ## License
 
-ISC License - see [LICENSE](LICENSE) for details.
+Apache 2.0 License - see [LICENSE](LICENSE) for details.
 
 ## Thanks
 

package/README.zh-CN.md

@@ -1,10 +1,26 @@
 # Kode - 终端 AI 助手
 
 [![npm version](https://badge.fury.io/js/@shareai-lab%2Fkode.svg)](https://www.npmjs.com/package/@shareai-lab/kode)
-[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 
 [English](README.md) | [贡献指南](CONTRIBUTING.md) | [文档](docs/)
 
+## 🎉 重磅消息：我们已切换至 Apache 2.0 开源协议！
+
+**开发者社区的福音来了！** 为了推动 AI 智能体技术的民主化进程，构建充满活力的创新生态，我们激动地宣布：Kode 已正式从 AGPLv3 协议升级为 **Apache 2.0 开源协议**。
+
+### 这对您意味着什么：
+- ✅ **完全自由**：在任何项目中使用 Kode - 无论是个人项目、商业产品还是企业方案
+- ✅ **无障碍创新**：构建专有解决方案，无需开源您的代码
+- ✅ **极简要求**：仅需保留版权声明和许可信息
+- ✅ **共创未来**：与全球开发者一起，加速世界向 AI 驱动生产的转型
+
+让我们携手共建未来！🚀
+
+## 📢 更新日志
+
+**2025-08-29**：我们添加了 Windows 电脑的运行支持！所有的 Windows 用户现在可以使用你电脑上的 Git Bash、Unix 子系统或 WSL（Windows Subsystem for Linux）来运行 Kode。
+
 Kode 是一个强大的 AI 助手，运行在你的终端中。它能理解你的代码库、编辑文件、运行命令，并为你处理整个开发工作流。
 
 > **⚠️ 安全提示**：Kode 默认以 YOLO 模式运行（等同于 Claude 的 `--dangerously-skip-permissions` 标志），跳过所有权限检查以获得最大生产力。YOLO 模式仅建议在安全可信的环境中处理非重要项目时使用。如果您正在处理重要文件或使用能力存疑的模型，我们强烈建议使用 `kode --safe` 启用权限检查和手动审批所有操作。
@@ -301,7 +317,7 @@ bun test
 
 ## 许可证
 
-ISC 许可证 - 详见 [LICENSE](LICENSE)。
+Apache 2.0 许可证 - 详见 [LICENSE](LICENSE)。
 
 ## 支持
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shareai-lab/kode",
-  "version": "1.0.81",
+  "version": "1.0.82",
   "bin": {
     "kode": "cli.js",
     "kwa": "cli.js",
@@ -11,7 +11,7 @@
   },
   "main": "cli.js",
   "author": "ShareAI-lab <ai-lab@foxmail.com>",
-  "license": "ISC",
+  "license": "Apache-2.0",
   "description": "AI-powered terminal assistant that understands your codebase, edits files, runs commands, and automates development workflows.",
   "homepage": "https://github.com/shareAI-lab/kode",
   "repository": {
@@ -76,12 +76,15 @@
     "lru-cache": "^11.1.0",
     "marked": "^15.0.12",
     "nanoid": "^5.1.5",
+    "node-fetch": "^3.3.2",
+    "node-html-parser": "^7.0.1",
     "openai": "^4.104.0",
     "react": "18.3.1",
     "semver": "^7.7.2",
     "shell-quote": "^1.8.3",
     "spawn-rx": "^5.1.2",
     "tsx": "^4.20.3",
+    "turndown": "^7.2.1",
     "undici": "^7.11.0",
     "wrap-ansi": "^9.0.0",
     "zod": "^3.25.76",
@@ -113,4 +116,4 @@
     "terminal",
     "command-line"
   ]
-}
+}

package/src/components/ModelSelector.tsx

@@ -480,6 +480,7 @@ export function ModelSelector({
           'x-api-key': apiKey,
           'anthropic-version': '2023-06-01',
           'Content-Type': 'application/json',
+          'Authorization': `Bearer ${apiKey}`
         },
       })
 
@@ -1846,7 +1847,7 @@ export function ModelSelector({
         }
 
         // Use the verifyApiKey function which uses the official Anthropic SDK
-        const isValid = await verifyApiKey(apiKey, testBaseURL)
+        const isValid = await verifyApiKey(apiKey, testBaseURL, selectedProvider)
 
         if (isValid) {
           return {

package/src/query.ts

@@ -206,10 +206,10 @@ export async function* query(
               typeof lastUserMessage.message.content === 'string'
                 ? reminders + lastUserMessage.message.content
                 : [
-                    { type: 'text', text: reminders },
                     ...(Array.isArray(lastUserMessage.message.content)
                       ? lastUserMessage.message.content
                       : []),
+                    { type: 'text', text: reminders },
                   ],
           },
         }
@@ -567,8 +567,16 @@ async function* checkPermissionsAndCallTool(
   // (surprisingly, the model is not great at generating valid input)
   const isValidInput = tool.inputSchema.safeParse(input)
   if (!isValidInput.success) {
+    // Create a more helpful error message for common cases
+    let errorMessage = `InputValidationError: ${isValidInput.error.message}`
+    
+    // Special handling for the "View" tool (FileReadTool) being called with empty parameters
+    if (tool.name === 'View' && Object.keys(input).length === 0) {
+      errorMessage = `Error: The View tool requires a 'file_path' parameter to specify which file to read. Please provide the absolute path to the file you want to view. For example: {"file_path": "/path/to/file.txt"}`
+    }
+    
     logEvent('tengu_tool_use_error', {
-      error: `InputValidationError: ${isValidInput.error.message}`,
+      error: errorMessage,
       messageID: assistantMessage.message.id,
       toolName: tool.name,
       toolInput: JSON.stringify(input).slice(0, 200),
@@ -576,7 +584,7 @@ async function* checkPermissionsAndCallTool(
     yield createUserMessage([
       {
         type: 'tool_result',
-        content: `InputValidationError: ${isValidInput.error.message}`,
+        content: errorMessage,
         is_error: true,
         tool_use_id: toolUseID,
       },

package/src/services/claude.ts

@@ -962,6 +962,84 @@ export function resetAnthropicClient(): void {
  * 4. Fallback region (us-east5)
  */
 
+/**
+ * Manage cache control to ensure it doesn't exceed Claude's 4 cache block limit
+ * Priority:
+ * 1. System prompts (high priority)
+ * 2. Long documents or reference materials (high priority)
+ * 3. Reusable context (medium priority)
+ * 4. Short messages or one-time content (no caching)
+ */
+function applyCacheControlWithLimits(
+  systemBlocks: TextBlockParam[],
+  messageParams: MessageParam[]
+): { systemBlocks: TextBlockParam[]; messageParams: MessageParam[] } {
+  if (!PROMPT_CACHING_ENABLED) {
+    return { systemBlocks, messageParams }
+  }
+
+  const maxCacheBlocks = 4
+  let usedCacheBlocks = 0
+
+  // 1. Prioritize adding cache to system prompts (highest priority)
+  const processedSystemBlocks = systemBlocks.map((block, index) => {
+    if (usedCacheBlocks < maxCacheBlocks && block.text.length > 1000) {
+      usedCacheBlocks++
+      return {
+        ...block,
+        cache_control: { type: 'ephemeral' as const }
+      }
+    }
+    const { cache_control, ...blockWithoutCache } = block
+    return blockWithoutCache
+  })
+
+  // 2. Add cache to message content based on priority
+  const processedMessageParams = messageParams.map((message, messageIndex) => {
+    if (Array.isArray(message.content)) {
+      const processedContent = message.content.map((contentBlock, blockIndex) => {
+        // Determine whether this content block should be cached
+        const shouldCache = 
+          usedCacheBlocks < maxCacheBlocks &&
+          contentBlock.type === 'text' &&
+          typeof contentBlock.text === 'string' &&
+          (
+            // Long documents (over 2000 characters)
+            contentBlock.text.length > 2000 ||
+            // Last content block of the last message (may be important context)
+            (messageIndex === messageParams.length - 1 && 
+             blockIndex === message.content.length - 1 &&
+             contentBlock.text.length > 500)
+          )
+
+        if (shouldCache) {
+          usedCacheBlocks++
+          return {
+            ...contentBlock,
+            cache_control: { type: 'ephemeral' as const }
+          }
+        }
+
+        // Remove existing cache_control
+        const { cache_control, ...blockWithoutCache } = contentBlock as any
+        return blockWithoutCache
+      })
+
+      return {
+        ...message,
+        content: processedContent
+      }
+    }
+
+    return message
+  })
+
+  return {
+    systemBlocks: processedSystemBlocks,
+    messageParams: processedMessageParams
+  }
+}
+
 export function userMessageToMessageParam(
   message: UserMessage,
   addCache = false,
@@ -974,23 +1052,13 @@ export function userMessageToMessageParam(
           {
             type: 'text',
             text: message.message.content,
-            ...(PROMPT_CACHING_ENABLED
-              ? { cache_control: { type: 'ephemeral' } }
-              : {}),
           },
         ],
       }
     } else {
       return {
         role: 'user',
-        content: message.message.content.map((_, i) => ({
-          ..._,
-          ...(i === message.message.content.length - 1
-            ? PROMPT_CACHING_ENABLED
-              ? { cache_control: { type: 'ephemeral' } }
-              : {}
-            : {}),
-        })),
+        content: message.message.content.map((_) => ({ ..._ })),
       }
     }
   }
@@ -1012,25 +1080,13 @@ export function assistantMessageToMessageParam(
           {
             type: 'text',
             text: message.message.content,
-            ...(PROMPT_CACHING_ENABLED
-              ? { cache_control: { type: 'ephemeral' } }
-              : {}),
           },
         ],
       }
     } else {
       return {
         role: 'assistant',
-        content: message.message.content.map((_, i) => ({
-          ..._,
-          ...(i === message.message.content.length - 1 &&
-          _.type !== 'thinking' &&
-          _.type !== 'redacted_thinking'
-            ? PROMPT_CACHING_ENABLED
-              ? { cache_control: { type: 'ephemeral' } }
-              : {}
-            : {}),
-        })),
+        content: message.message.content.map((_) => ({ ..._ })),
       }
     }
   }
@@ -1383,9 +1439,6 @@ async function queryAnthropicNative(
 
   const system: TextBlockParam[] = splitSysPromptPrefix(systemPrompt).map(
     _ => ({
-      ...(PROMPT_CACHING_ENABLED
-        ? { cache_control: { type: 'ephemeral' } }
-        : {}),
       text: _,
       type: 'text',
     }),
@@ -1404,6 +1457,10 @@ async function queryAnthropicNative(
   )
 
   const anthropicMessages = addCacheBreakpoints(messages)
+
+  //  apply cache control
+  const { systemBlocks: processedSystem, messageParams: processedMessages } = 
+    applyCacheControlWithLimits(system, anthropicMessages)
   const startIncludingRetries = Date.now()
 
   // 记录系统提示构建过程
@@ -1426,8 +1483,8 @@ async function queryAnthropicNative(
       const params: Anthropic.Beta.Messages.MessageCreateParams = {
         model,
         max_tokens: getMaxTokensFromProfile(modelProfile),
-        messages: anthropicMessages,
-        system,
+        messages: processedMessages,
+        system: processedSystem,
         tools: toolSchemas.length > 0 ? toolSchemas : undefined,
         tool_choice: toolSchemas.length > 0 ? { type: 'auto' } : undefined,
       }
@@ -1450,6 +1507,7 @@ async function queryAnthropicNative(
           : null,
         maxTokens: params.max_tokens,
         temperature: MAIN_QUERY_TEMPERATURE,
+        params: params,
         messageCount: params.messages?.length || 0,
         streamMode: true,
         toolsCount: toolSchemas.length,
@@ -1471,6 +1529,7 @@ async function queryAnthropicNative(
         let finalResponse: any | null = null
         let messageStartEvent: any = null
         const contentBlocks: any[] = []
+        const inputJSONBuffers = new Map<number, string>()
         let usage: any = null
         let stopReason: string | null = null
         let stopSequence: string | null = null
@@ -1484,30 +1543,81 @@ async function queryAnthropicNative(
             })
             throw new Error('Request was cancelled')
           }
-          if (event.type === 'message_start') {
-            messageStartEvent = event
-            finalResponse = {
-              ...event.message,
-              content: [], // Will be populated from content blocks
-            }
-          } else if (event.type === 'content_block_start') {
-            contentBlocks[event.index] = { ...event.content_block }
-          } else if (event.type === 'content_block_delta') {
-            if (!contentBlocks[event.index]) {
-              contentBlocks[event.index] = {
-                type: event.delta.type === 'text_delta' ? 'text' : 'unknown',
-                text: '',
+          
+          switch (event.type) {
+            case 'message_start':
+              messageStartEvent = event
+              finalResponse = {
+                ...event.message,
+                content: [], // Will be populated from content blocks
               }
-            }
-            if (event.delta.type === 'text_delta') {
-              contentBlocks[event.index].text += event.delta.text
-            }
-          } else if (event.type === 'message_delta') {
-            if (event.delta.stop_reason) stopReason = event.delta.stop_reason
-            if (event.delta.stop_sequence)
-              stopSequence = event.delta.stop_sequence
-            if (event.usage) usage = { ...usage, ...event.usage }
-          } else if (event.type === 'message_stop') {
+              break
+              
+            case 'content_block_start':
+              contentBlocks[event.index] = { ...event.content_block }
+              // Initialize JSON buffer for tool_use blocks
+              if (event.content_block.type === 'tool_use') {
+                inputJSONBuffers.set(event.index, '')
+              }
+              break
+              
+            case 'content_block_delta':
+              const blockIndex = event.index
+              
+              // Ensure content block exists
+              if (!contentBlocks[blockIndex]) {
+                contentBlocks[blockIndex] = {
+                  type: event.delta.type === 'text_delta' ? 'text' : 'tool_use',
+                  text: event.delta.type === 'text_delta' ? '' : undefined,
+                }
+                if (event.delta.type === 'input_json_delta') {
+                  inputJSONBuffers.set(blockIndex, '')
+                }
+              }
+              
+              if (event.delta.type === 'text_delta') {
+                contentBlocks[blockIndex].text += event.delta.text
+              } else if (event.delta.type === 'input_json_delta') {
+                const currentBuffer = inputJSONBuffers.get(blockIndex) || ''
+                inputJSONBuffers.set(blockIndex, currentBuffer + event.delta.partial_json)
+              }
+              break
+              
+            case 'message_delta':
+              if (event.delta.stop_reason) stopReason = event.delta.stop_reason
+              if (event.delta.stop_sequence) stopSequence = event.delta.stop_sequence
+              if (event.usage) usage = { ...usage, ...event.usage }
+              break
+              
+            case 'content_block_stop':
+              const stopIndex = event.index
+              const block = contentBlocks[stopIndex]
+              
+              if (block?.type === 'tool_use' && inputJSONBuffers.has(stopIndex)) {
+                const jsonStr = inputJSONBuffers.get(stopIndex)
+                if (jsonStr) {
+                  try {
+                    block.input = JSON.parse(jsonStr)
+                  } catch (error) {
+                    debugLogger.error('JSON_PARSE_ERROR', {
+                      blockIndex: stopIndex,
+                      jsonStr,
+                      error: error instanceof Error ? error.message : String(error)
+                    })
+                    block.input = {}
+                  }
+                  inputJSONBuffers.delete(stopIndex)
+                }
+              }
+              break
+              
+            case 'message_stop':
+              // Clear any remaining buffers
+              inputJSONBuffers.clear()
+              break
+          }
+          
+          if (event.type === 'message_stop') {
             break
           }
         }
@@ -1557,6 +1667,10 @@ async function queryAnthropicNative(
       }
     }, { signal })
 
+    debugLogger.api('ANTHROPIC_API_CALL_SUCCESS', {
+      content: response.content
+    })
+
     const ttftMs = start - Date.now()
     const durationMs = Date.now() - startIncludingRetries
 

package/src/tools/URLFetcherTool/URLFetcherTool.tsx

@@ -0,0 +1,178 @@
+import { Box, Text } from 'ink'
+import React from 'react'
+import { z } from 'zod'
+import fetch from 'node-fetch'
+import { Cost } from '../../components/Cost'
+import { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage'
+import { Tool, ToolUseContext } from '../../Tool'
+import { DESCRIPTION, TOOL_NAME_FOR_PROMPT } from './prompt'
+import { convertHtmlToMarkdown } from './htmlToMarkdown'
+import { urlCache } from './cache'
+import { queryQuick } from '../../services/claude'
+
+const inputSchema = z.strictObject({
+  url: z.string().url().describe('The URL to fetch content from'),
+  prompt: z.string().describe('The prompt to run on the fetched content'),
+})
+
+type Input = z.infer<typeof inputSchema>
+type Output = {
+  url: string
+  fromCache: boolean
+  aiAnalysis: string
+}
+
+function normalizeUrl(url: string): string {
+  // Auto-upgrade HTTP to HTTPS
+  if (url.startsWith('http://')) {
+    return url.replace('http://', 'https://')
+  }
+  return url
+}
+
+export const URLFetcherTool = {
+  name: TOOL_NAME_FOR_PROMPT,
+  async description() {
+    return DESCRIPTION
+  },
+  userFacingName: () => 'URL Fetcher',
+  inputSchema,
+  isReadOnly: () => true,
+  isConcurrencySafe: () => true,
+  async isEnabled() {
+    return true
+  },
+  needsPermissions() {
+    return false
+  },
+  async prompt() {
+    return DESCRIPTION
+  },
+  renderToolUseMessage({ url, prompt }: Input) {
+    return `Fetching content from ${url} and analyzing with prompt: "${prompt}"`
+  },
+  renderToolUseRejectedMessage() {
+    return <FallbackToolUseRejectedMessage />
+  },
+  renderToolResultMessage(output: Output) {
+    const statusText = output.fromCache ? 'from cache' : 'fetched'
+    
+    return (
+      <Box justifyContent="space-between" width="100%">
+        <Box flexDirection="row">
+          <Text>&nbsp;&nbsp;⎿ &nbsp;Content </Text>
+          <Text bold>{statusText} </Text>
+          <Text>and analyzed</Text>
+        </Box>
+        <Cost costUSD={0} durationMs={0} debug={false} />
+      </Box>
+    )
+  },
+  renderResultForAssistant(output: Output) {
+    if (!output.aiAnalysis.trim()) {
+      return `No content could be analyzed from URL: ${output.url}`
+    }
+    
+    return output.aiAnalysis
+  },
+  async *call({ url, prompt }: Input, {}: ToolUseContext) {
+    const normalizedUrl = normalizeUrl(url)
+    
+    try {
+      let content: string
+      let fromCache = false
+
+      // Check cache first
+      const cachedContent = urlCache.get(normalizedUrl)
+      if (cachedContent) {
+        content = cachedContent
+        fromCache = true
+      } else {
+        // Fetch from URL with AbortController for timeout
+        const abortController = new AbortController()
+        const timeout = setTimeout(() => abortController.abort(), 30000)
+        
+        const response = await fetch(normalizedUrl, {
+          method: 'GET',
+          headers: {
+            'User-Agent': 'Mozilla/5.0 (compatible; URLFetcher/1.0)',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Accept-Encoding': 'gzip, deflate',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1',
+          },
+          signal: abortController.signal,
+          redirect: 'follow',
+        })
+        
+        clearTimeout(timeout)
+
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+        }
+
+        const contentType = response.headers.get('content-type') || ''
+        if (!contentType.includes('text/') && !contentType.includes('application/')) {
+          throw new Error(`Unsupported content type: ${contentType}`)
+        }
+
+        const html = await response.text()
+        content = convertHtmlToMarkdown(html)
+        
+        // Cache the result
+        urlCache.set(normalizedUrl, content)
+        fromCache = false
+      }
+
+      // Truncate content if too large (keep within reasonable token limits)
+      const maxContentLength = 50000 // ~15k tokens approximately
+      const truncatedContent = content.length > maxContentLength 
+        ? content.substring(0, maxContentLength) + '\n\n[Content truncated due to length]'
+        : content
+
+      // AI Analysis - always performed fresh, even with cached content
+      const systemPrompt = [
+        'You are analyzing web content based on a user\'s specific request.',
+        'The content has been extracted from a webpage and converted to markdown.',
+        'Provide a focused response that directly addresses the user\'s prompt.',
+      ]
+
+      const userPrompt = `Here is the content from ${normalizedUrl}:
+
+${truncatedContent}
+
+User request: ${prompt}`
+
+      const aiResponse = await queryQuick({
+        systemPrompt,
+        userPrompt,
+        enablePromptCaching: false,
+      })
+
+      const output: Output = {
+        url: normalizedUrl,
+        fromCache,
+        aiAnalysis: aiResponse.message.content[0]?.text || 'Unable to analyze content',
+      }
+
+      yield {
+        type: 'result' as const,
+        resultForAssistant: this.renderResultForAssistant(output),
+        data: output,
+      }
+    } catch (error: any) {
+      const output: Output = {
+        url: normalizedUrl,
+        fromCache: false,
+        aiAnalysis: '',
+      }
+      
+      yield {
+        type: 'result' as const,
+        resultForAssistant: `Error processing URL ${normalizedUrl}: ${error.message}`,
+        data: output,
+      }
+    }
+  },
+} satisfies Tool<typeof inputSchema, Output>