@opentiny/tiny-robot-cli 0.5.2-alpha.3 → 1.0.0-beta.1

package/templates/basic/src/composables/useChat.ts

@@ -1,129 +0,0 @@
-import { sseStreamToGenerator, toolPlugin, useConversation } from '@opentiny/tiny-robot-kit'
-import { computed, ref } from 'vue'
-import type { McpServerKey } from '../mcpServers'
-import { useMcp } from './useMcp'
-import { useModel } from './useModel'
-
-function createChatStore() {
-  const inputMessage = ref('')
-  const modelStore = useModel()
-  const mcpStore = useMcp()
-  const { listTools, callTool } = mcpStore
-  const { selectedModel, getSelectedModelParams } = modelStore
-
-  const useConversationReturn = useConversation({
-    useMessageOptions: {
-      responseProvider: async (requestBody, abortSignal) => {
-        const currentModel = selectedModel.value
-        if (!currentModel) {
-          throw new Error('No model selected.')
-        }
-        if (!currentModel.apiKey) {
-          throw new Error(`Missing API key for provider "${currentModel.provider}".`)
-        }
-
-        const response = await fetch(currentModel.apiUrl, {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            Authorization: `Bearer ${currentModel.apiKey}`,
-          },
-          body: JSON.stringify({
-            ...requestBody,
-            ...getSelectedModelParams(),
-            stream: true,
-          }),
-          signal: abortSignal,
-        })
-
-        if (!response.ok) {
-          const detail = await response.text().catch(() => '')
-          throw new Error(`HTTP ${response.status}: ${response.statusText}${detail ? ` - ${detail}` : ''}`)
-        }
-
-        return sseStreamToGenerator(response, { signal: abortSignal })
-      },
-      initialMessages: [
-        {
-          role: 'system',
-          content: 'You are a helpful assistant.',
-        },
-      ],
-      plugins: [
-        toolPlugin({
-          getTools: async () => {
-            const mcpTools = await listTools()
-            return mcpTools.map((tool) => ({
-              type: 'function',
-              function: {
-                name: tool.name,
-                description: tool.description || '',
-                parameters: (tool.inputSchema as Record<string, unknown> | undefined) || {
-                  type: 'object',
-                  properties: {},
-                },
-              },
-            }))
-          },
-          callTool: async (toolCall) => {
-            const toolName = toolCall.function?.name
-            if (!toolName || !toolName.includes('__')) {
-              throw new Error(`Unknown MCP tool name: ${toolName || '(empty)'}`)
-            }
-            const [serverKeyPart, ...nameParts] = toolName.split('__')
-            const originalToolName = nameParts.join('__')
-            const serverKey = serverKeyPart as McpServerKey
-            if (!originalToolName) {
-              throw new Error(`Unknown MCP tool name: ${toolName}`)
-            }
-            const args = JSON.parse(toolCall.function?.arguments || '{}') as Record<string, unknown>
-            return await callTool(serverKey, originalToolName, args)
-          },
-        }),
-        {
-          onError({ currentTurn, error }) {
-            console.error(error)
-            currentTurn[currentTurn.length - 1].content = String(error)
-          },
-        },
-      ],
-    },
-    autoSaveMessages: true,
-  })
-
-  const messages = computed(() => useConversationReturn.activeConversation.value?.engine.messages.value || [])
-  const isProcessing = computed(
-    () => useConversationReturn.activeConversation.value?.engine.isProcessing.value ?? false,
-  )
-
-  function sendMessage(content: string) {
-    const value = content?.trim()
-    if (!value || isProcessing.value) {
-      return
-    }
-    if (!useConversationReturn.activeConversationId.value) {
-      useConversationReturn.createConversation({ title: value.slice(0, 24) })
-    }
-    useConversationReturn.sendMessage(value)
-    inputMessage.value = ''
-  }
-
-  return {
-    ...useConversationReturn,
-    ...modelStore,
-    messages,
-    inputMessage,
-    isProcessing,
-    sendMessage,
-  }
-}
-
-type ChatStore = ReturnType<typeof createChatStore>
-let chatStore: ChatStore | null = null
-
-export function useChat() {
-  if (!chatStore) {
-    chatStore = createChatStore()
-  }
-  return chatStore
-}

package/templates/basic/src/composables/useMcp.ts

@@ -1,170 +0,0 @@
-import { computed, ref } from 'vue'
-import { Client } from '@modelcontextprotocol/sdk/client'
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse'
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp'
-import type { CallToolRequest } from '@modelcontextprotocol/sdk/types'
-import { McpServers, type McpServerConfig, type McpServerKey } from '../mcpServers'
-
-type McpTool = Awaited<ReturnType<Client['listTools']>>['tools'][number]
-type McpToolCallResult = Awaited<ReturnType<Client['callTool']>>
-
-function createMcpClient(serverKey: McpServerKey, server: McpServerConfig) {
-  const client = new Client({
-    name: serverKey,
-    version: '0.1.0',
-  })
-  const requestInit = {
-    headers: server.headers,
-  }
-  const transport =
-    server.type === 'streamableHttp'
-      ? new StreamableHTTPClientTransport(new URL(server.baseUrl), { requestInit })
-      : new SSEClientTransport(new URL(server.baseUrl), { requestInit })
-  return { client, transport }
-}
-
-function getServerByKey(serverKey: McpServerKey): McpServerConfig {
-  const server = McpServers[serverKey]
-  if (!server) {
-    throw new Error(`Unknown MCP server key: ${serverKey}`)
-  }
-  return server
-}
-
-async function listMcpToolsFromServer(serverKey: McpServerKey): Promise<McpTool[]> {
-  const server = getServerByKey(serverKey)
-  const { client, transport } = createMcpClient(serverKey, server)
-  try {
-    await client.connect(transport)
-    const response = await client.listTools()
-    return response.tools
-  } finally {
-    await client.close().catch(() => undefined)
-  }
-}
-
-async function callMcpToolFromServer(
-  serverKey: McpServerKey,
-  toolName: string,
-  args: CallToolRequest['params']['arguments'] = {},
-): Promise<McpToolCallResult> {
-  const server = getServerByKey(serverKey)
-  const { client, transport } = createMcpClient(serverKey, server)
-  try {
-    await client.connect(transport)
-    return await client.callTool({
-      name: toolName,
-      arguments: args,
-    })
-  } finally {
-    await client.close().catch(() => undefined)
-  }
-}
-
-function createMcpStore() {
-  // Added servers are selectable from McpServers and start empty by default.
-  const addedMcpServers = ref<McpServerKey[]>([])
-  const inUseMcpServers = ref<McpServerKey[]>([])
-
-  const availableMcpServers = computed(() => Object.keys(McpServers).map((serverKey) => serverKey as McpServerKey))
-
-  function addMcpServer(serverKey: McpServerKey) {
-    if (!McpServers[serverKey]) {
-      throw new Error(`Unknown MCP server key: ${serverKey}`)
-    }
-    if (!addedMcpServers.value.includes(serverKey)) {
-      addedMcpServers.value = [...addedMcpServers.value, serverKey]
-    }
-    // First add should enable the server immediately.
-    if (!inUseMcpServers.value.includes(serverKey)) {
-      inUseMcpServers.value = [...inUseMcpServers.value, serverKey]
-    }
-  }
-
-  function toggleMcpServer(serverKey: McpServerKey) {
-    if (!addedMcpServers.value.includes(serverKey)) {
-      throw new Error(`MCP server "${serverKey}" is not added.`)
-    }
-    if (inUseMcpServers.value.includes(serverKey)) {
-      inUseMcpServers.value = inUseMcpServers.value.filter((item) => item !== serverKey)
-      return
-    }
-    inUseMcpServers.value = [...inUseMcpServers.value, serverKey]
-  }
-
-  function removeMcpServer(serverKey: McpServerKey) {
-    if (!addedMcpServers.value.includes(serverKey)) {
-      return
-    }
-    addedMcpServers.value = addedMcpServers.value.filter((item) => item !== serverKey)
-    inUseMcpServers.value = inUseMcpServers.value.filter((item) => item !== serverKey)
-  }
-
-  function assertServerInUse(serverKey: McpServerKey) {
-    if (!inUseMcpServers.value.includes(serverKey)) {
-      throw new Error(`MCP server "${serverKey}" is not in use.`)
-    }
-  }
-
-  async function listTools(serverKey?: McpServerKey): Promise<McpTool[]> {
-    if (serverKey) {
-      return listMcpToolsFromServer(serverKey)
-    }
-
-    const resultEntries = await Promise.allSettled(
-      inUseMcpServers.value.map(async (key) => await listMcpToolsFromServer(key)),
-    )
-
-    const allTools: McpTool[] = []
-    resultEntries.forEach((item, index) => {
-      const serverKey = inUseMcpServers.value[index]
-      if (!serverKey) {
-        return
-      }
-      if (item.status === 'fulfilled') {
-        item.value.forEach((tool, toolIndex) => {
-          const originalName = typeof tool.name === 'string' ? tool.name : `tool_${toolIndex + 1}`
-          allTools.push({
-            ...tool,
-            name: `${serverKey}__${originalName}`,
-          })
-        })
-        return
-      }
-      console.error(`[MCP] Failed to list tools from "${serverKey}":`, item.reason)
-    })
-
-    return allTools
-  }
-
-  async function callTool(
-    serverKey: McpServerKey,
-    toolName: string,
-    args: Record<string, unknown> = {},
-  ): Promise<McpToolCallResult> {
-    assertServerInUse(serverKey)
-    return callMcpToolFromServer(serverKey, toolName, args)
-  }
-
-  return {
-    McpServers,
-    availableMcpServers,
-    addedMcpServers,
-    addMcpServer,
-    inUseMcpServers,
-    toggleMcpServer,
-    removeMcpServer,
-    listTools,
-    callTool,
-  }
-}
-
-type McpStore = ReturnType<typeof createMcpStore>
-let mcpStore: McpStore | null = null
-
-export function useMcp() {
-  if (!mcpStore) {
-    mcpStore = createMcpStore()
-  }
-  return mcpStore
-}

package/templates/basic/src/composables/useModel.ts

@@ -1,82 +0,0 @@
-import type { Component } from 'vue'
-import { computed, ref } from 'vue'
-import { ModelConfigs, type ModelConfigItem } from '../models'
-
-export interface ModelOption {
-  id: string
-  provider: string
-  name: string
-  model: string
-  icon: Component
-  apiUrl: string
-  apiKey?: string
-  capabilities?: ModelConfigItem['capabilities']
-}
-
-function createModelStore() {
-  const modelOptions: ModelOption[] = Object.entries(ModelConfigs).flatMap(([provider, config]) =>
-    config.models.map((modelItem) => ({
-      id: `${provider}:${modelItem.model}`,
-      provider,
-      name: modelItem.name,
-      model: modelItem.model,
-      icon: config.icon,
-      apiUrl: config.apiUrl,
-      apiKey: config.apiKey?.trim(),
-      capabilities: modelItem.capabilities,
-    })),
-  )
-
-  const selectedModelId = ref(modelOptions[0]?.id || '')
-  const selectedModel = computed<ModelOption | undefined>(() =>
-    modelOptions.find((item) => item.id === selectedModelId.value),
-  )
-
-  const thinkingEnabled = ref(false)
-  const searchEnabled = ref(false)
-
-  const supportsThinking = computed(() => Boolean(selectedModel.value?.capabilities?.thinking))
-  const supportsSearch = computed(() => Boolean(selectedModel.value?.capabilities?.search))
-
-  const hasApiConfig = computed(() => {
-    const current = selectedModel.value
-    return Boolean(current?.apiUrl && current?.apiKey)
-  })
-
-  function getSelectedModelParams(): Record<string, unknown> {
-    const current = selectedModel.value
-    if (!current) {
-      return {}
-    }
-
-    const { thinking, search } = current.capabilities ?? {}
-
-    return {
-      model: current.model,
-      ...(thinkingEnabled.value && thinking ? thinking : {}),
-      ...(searchEnabled.value && search ? search : {}),
-    }
-  }
-
-  return {
-    modelOptions,
-    selectedModelId,
-    selectedModel,
-    thinkingEnabled,
-    searchEnabled,
-    supportsThinking,
-    supportsSearch,
-    hasApiConfig,
-    getSelectedModelParams,
-  }
-}
-
-type ModelStore = ReturnType<typeof createModelStore>
-let modelStore: ModelStore | null = null
-
-export function useModel() {
-  if (!modelStore) {
-    modelStore = createModelStore()
-  }
-  return modelStore
-}

package/templates/basic/src/mcpServers.ts

@@ -1,40 +0,0 @@
-export type McpServerConfig = {
-  type: 'sse' | 'streamableHttp'
-  name: string
-  description?: string
-  baseUrl: string
-  headers?: Record<string, string>
-  logoUrl?: string
-}
-
-export const McpServers = {
-  'china-railway': {
-    type: 'sse',
-    description: '开源社区开发者封装,提供 12306购票信息查询等服务',
-    name: '12306 车票查询',
-    baseUrl: 'https://dashscope.aliyuncs.com/api/v1/mcps/china-railway/sse',
-    logoUrl: 'https://img.alicdn.com/imgextra/i3/O1CN01yUKR7l1FrpKqvxNjt_!!6000000000541-2-tps-512-512.png',
-    headers: {
-      Authorization: `Bearer ${import.meta.env.VITE_ALIYUN_DASHSCOPE_KEY}`,
-    },
-  },
-  'amap-maps': {
-    type: 'sse',
-    description:
-      '高德地图MCP Server现已覆盖15大核心接口，提供全场景覆盖的地理信息服务，包括生成专属地图、导航到目的地、打车、地理编码、逆地理编码、IP定位、天气查询、骑行路径规划、步行路径规划、驾车路径规划、公交路径规划、距离测量、关键词搜索、周边搜索、详情搜索等。',
-    name: '高德地图',
-    baseUrl: 'https://dashscope.aliyuncs.com/api/v1/mcps/amap-maps/sse',
-    logoUrl: 'https://img.alicdn.com/imgextra/i4/O1CN01iPPabT1EGRN6uatHP_!!6000000000324-0-tps-512-512.jpg',
-    headers: {
-      Authorization: `Bearer ${import.meta.env.VITE_ALIYUN_DASHSCOPE_KEY}`,
-    },
-  },
-  'model-context-protocol-mcp': {
-    type: 'streamableHttp',
-    name: 'Model Context Protocol MCP',
-    baseUrl: window.location.origin + '/modelcontextprotocol-mcp',
-    logoUrl: window.location.origin + '/modelcontextprotocol.png',
-  },
-} satisfies Record<string, McpServerConfig>
-
-export type McpServerKey = keyof typeof McpServers

package/templates/basic/src/models.ts

@@ -1,81 +0,0 @@
-import { type Component } from 'vue'
-import { IconModelAliyunBailian, IconModelDeepseek } from './components/icons'
-
-export interface ModelCapabilities {
-  thinking?: Record<string, unknown> | false
-  search?: Record<string, unknown> | false
-}
-
-export interface ModelConfigItem {
-  name: string
-  model: string
-  capabilities?: ModelCapabilities
-}
-
-export interface ProviderModelConfig {
-  apiUrl: string
-  icon: Component
-  apiKey?: string
-  models: ModelConfigItem[]
-}
-
-export const ModelConfigs: Record<string, ProviderModelConfig> = {
-  aliyun: {
-    apiUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions',
-    icon: IconModelAliyunBailian,
-    apiKey: import.meta.env.VITE_ALIYUN_DASHSCOPE_KEY,
-    models: [
-      {
-        name: 'Qwen Flash',
-        model: 'qwen-flash',
-        capabilities: {
-          thinking: {
-            enable_thinking: true,
-          },
-          search: {
-            enable_search: true,
-          },
-        },
-      },
-      {
-        name: 'Qwen Plus',
-        model: 'qwen-plus',
-        capabilities: {
-          thinking: {
-            enable_thinking: true,
-          },
-          search: {
-            enable_search: true,
-          },
-        },
-      },
-      {
-        name: 'Qwen Max',
-        model: 'qwen-max',
-        capabilities: {
-          thinking: {
-            enable_thinking: true,
-          },
-          search: {
-            enable_search: true,
-          },
-        },
-      },
-    ],
-  },
-  deepseek: {
-    apiUrl: 'https://api.deepseek.com/chat/completions',
-    icon: IconModelDeepseek,
-    apiKey: import.meta.env.VITE_DEEPSEEK_API_KEY,
-    models: [
-      {
-        name: 'DeepSeek V4 Flash',
-        model: 'deepseek-v4-flash',
-      },
-      {
-        name: 'DeepSeek V4 Pro',
-        model: 'deepseek-v4-pro',
-      },
-    ],
-  },
-}