@agentor/dashscope 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Demo Macro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,264 @@
+# @agentor/dashscope
+
+![npm version](https://img.shields.io/npm/v/@agentor/dashscope)
+![npm downloads](https://img.shields.io/npm/dw/@agentor/dashscope)
+![npm license](https://img.shields.io/npm/l/@agentor/dashscope)
+
+> [AI SDK](https://ai-sdk.dev/) provider for [Alibaba Cloud DashScope (Bailian)](https://help.aliyun.com/en/model-studio/) API.
+
+## Features
+
+- **Chat Completions API** - Standard `/chat/completions` with function calling, streaming, and reasoning
+- **Responses API** - `/responses` endpoint with built-in tools support
+- **Built-in Tools** - Web search, code interpreter, web extractor, file search, image search, MCP integration
+- **Thinking Mode** - Enable reasoning/thinking with configurable budget
+- **Multi-region** - Beijing, Singapore, US, Germany regions
+- **TypeScript-First** - Full type safety with comprehensive TypeScript support
+
+## Installation
+
+```bash
+# Install with npm
+$ npm install @agentor/dashscope
+
+# Install with yarn
+$ yarn add @agentor/dashscope
+
+# Install with pnpm
+$ pnpm add @agentor/dashscope
+```
+
+## Quick Start
+
+### Setup
+
+```typescript
+import { createDashScope } from "@agentor/dashscope";
+
+const dashscope = createDashScope({
+  apiKey: process.env.DASHSCOPE_API_KEY,
+});
+```
+
+Or use the default instance (reads `DASHSCOPE_API_KEY` from environment):
+
+```typescript
+import { dashscope } from "@agentor/dashscope";
+```
+
+### Basic Chat
+
+```typescript
+import { dashscope } from "@agentor/dashscope";
+import { generateText } from "ai";
+
+const result = await generateText({
+  model: dashscope("qwen3.5-flash"),
+  prompt: "Introduce yourself in one sentence.",
+});
+
+console.log(result.text);
+```
+
+### Streaming
+
+```typescript
+import { streamText } from "ai";
+
+const result = streamText({
+  model: dashscope("qwen3.5-flash"),
+  prompt: "Explain the Vercel AI SDK in three sentences.",
+});
+
+for await (const part of result.textStream) {
+  process.stdout.write(part);
+}
+```
+
+### Function Calling
+
+```typescript
+import { generateText, hasToolCall, tool } from "ai";
+import { z } from "zod/v4";
+
+const result = await generateText({
+  model: dashscope("qwen3.5-flash"),
+  tools: {
+    weather: tool({
+      description: "Get weather information for a city",
+      inputSchema: z.object({
+        city: z.string().describe("City name"),
+      }),
+      execute: async ({ city }) => {
+        return `${city}: Sunny, 25°C`;
+      },
+    }),
+  },
+  prompt: "What's the weather in Beijing?",
+  stopWhen: hasToolCall("weather"),
+});
+```
+
+## Chat Completions API
+
+### Web Search
+
+Enable web search via `providerOptions`:
+
+```typescript
+await generateText({
+  model: dashscope("qwen3.5-flash"),
+  providerOptions: {
+    dashscope: {
+      enableSearch: true,
+    },
+  },
+  prompt: "What are the latest tech news today?",
+});
+```
+
+### Code Interpreter
+
+Enable code interpreter (requires thinking mode):
+
+```typescript
+await generateText({
+  model: dashscope("qwen3.5-flash"),
+  providerOptions: {
+    dashscope: {
+      enableCodeInterpreter: true,
+      enableThinking: true,
+    },
+  },
+  prompt: "Calculate the sum of the first 20 Fibonacci numbers.",
+});
+```
+
+### Thinking Mode
+
+Enable reasoning with configurable budget:
+
+```typescript
+await generateText({
+  model: dashscope("qwen3.5-flash"),
+  providerOptions: {
+    dashscope: {
+      enableThinking: true,
+      thinkingBudget: 5000,
+    },
+  },
+  prompt: "Which is larger, 9.11 or 9.9?",
+});
+```
+
+## Responses API
+
+Use the `responses` namespace for the Responses API with built-in tools:
+
+```typescript
+import { generateText } from "ai";
+
+const result = await generateText({
+  model: dashscope.responses("qwen3.5-flash"),
+  prompt: "Search the web for the latest news.",
+});
+```
+
+### Built-in Tools
+
+#### Web Search
+
+```typescript
+import { dashscope } from "@agentor/dashscope";
+import { generateText } from "ai";
+
+const result = await generateText({
+  model: dashscope.responses("qwen3.5-flash"),
+  tools: [dashscope.responses.tools.webSearch()],
+  prompt: "What are the latest tech news today?",
+});
+```
+
+#### Code Interpreter
+
+```typescript
+const result = await generateText({
+  model: dashscope.responses("qwen3.5-flash"),
+  tools: [dashscope.responses.tools.codeInterpreter()],
+  prompt: "Calculate the sum of the first 20 Fibonacci numbers.",
+});
+```
+
+#### Web Extractor
+
+```typescript
+const result = await generateText({
+  model: dashscope.responses("qwen3.5-flash"),
+  tools: [dashscope.responses.tools.webExtractor()],
+  prompt: "Extract the main content from https://example.com",
+});
+```
+
+#### File Search
+
+```typescript
+const result = await generateText({
+  model: dashscope.responses("qwen3.5-flash"),
+  tools: [
+    dashscope.responses.tools.fileSearch({
+      vectorStoreIds: ["vs-xxx"],
+    }),
+  ],
+  prompt: "Find documents about machine learning.",
+});
+```
+
+#### MCP Integration
+
+```typescript
+const result = await generateText({
+  model: dashscope.responses("qwen3.5-flash"),
+  tools: [
+    dashscope.responses.tools.mcp({
+      serverProtocol: "sse",
+      serverLabel: "my-mcp-server",
+      serverUrl: "https://example.com/mcp/sse",
+    }),
+  ],
+  prompt: "Use the MCP tool to get data.",
+});
+```
+
+### Multi-turn Conversation
+
+Use `previousResponseId` for multi-turn conversations:
+
+```typescript
+const first = await generateText({
+  model: dashscope.responses("qwen3.5-flash"),
+  providerOptions: {
+    dashscope: {
+      previousResponseId: first.response.id,
+    },
+  },
+  prompt: "Follow up question...",
+});
+```
+
+## Provider Configuration
+
+```typescript
+import { createDashScope } from "@agentor/dashscope";
+
+const dashscope = createDashScope({
+  apiKey: "sk-xxx",                       // or set DASHSCOPE_API_KEY env var
+  region: "beijing",                       // beijing | singapore | us | germany
+  workspaceId: "ws-xxx",                   // required for germany region
+  baseURL: "https://custom-endpoint.com",  // override default base URL
+  headers: { "X-Custom-Header": "value" }, // custom headers
+});
+```
+
+## License
+
+MIT © [Demo Macro](https://www.demomacro.com/)

package/dist/index.d.mts

@@ -0,0 +1,210 @@
+import * as _$_ai_sdk_provider_utils0 from "@ai-sdk/provider-utils";
+import { FetchFunction } from "@ai-sdk/provider-utils";
+import { LanguageModelV3 } from "@ai-sdk/provider";
+
+//#region src/tools.d.ts
+declare const webSearchToolFactory: _$_ai_sdk_provider_utils0.ProviderToolFactoryWithOutputSchema<Record<string, never>, {
+  query?: string;
+  sources?: Array<{
+    type: "url";
+    url: string;
+  }>;
+}, {
+  /** Force web search even when the model doesn't think it's necessary. */forcedSearch?: boolean;
+  /**
+   * Search strategy. Only applicable to qwen3-max thinking mode.
+   * - "enable": enable search
+   * - "enable_with_history": enable search with history context
+   */
+  searchStrategy?: "enable" | "enable_with_history";
+}>;
+declare const codeInterpreterToolFactory: _$_ai_sdk_provider_utils0.ProviderToolFactoryWithOutputSchema<Record<string, never>, {
+  code?: string;
+  outputs?: Array<{
+    type: "logs";
+    logs?: string;
+  }>;
+}, Record<string, never>>;
+declare const webExtractorToolFactory: _$_ai_sdk_provider_utils0.ProviderToolFactoryWithOutputSchema<Record<string, never>, {
+  urls?: string[];
+  goal?: string;
+  output?: string;
+}, Record<string, never>>;
+declare const fileSearchToolFactory: _$_ai_sdk_provider_utils0.ProviderToolFactoryWithOutputSchema<Record<string, never>, {
+  queries?: string[];
+  results?: Array<{
+    fileId?: string;
+    filename?: string;
+    score?: number;
+    text?: string;
+  }>;
+}, {
+  /** Vector store IDs (knowledge base IDs) to search. Currently only 1 is supported. */vectorStoreIds: string[];
+}>;
+declare const webSearchImageToolFactory: _$_ai_sdk_provider_utils0.ProviderToolFactoryWithOutputSchema<Record<string, never>, {
+  queries?: string[];
+}, Record<string, never>>;
+declare const imageSearchToolFactory: _$_ai_sdk_provider_utils0.ProviderToolFactoryWithOutputSchema<Record<string, never>, Record<string, never>, Record<string, never>>;
+declare const mcpToolFactory: _$_ai_sdk_provider_utils0.ProviderToolFactoryWithOutputSchema<Record<string, never>, Record<string, never>, {
+  /** Communication protocol with the MCP service, e.g. "sse". */serverProtocol: string; /** Label to identify the MCP server. */
+  serverLabel: string; /** URL for the MCP server endpoint. */
+  serverUrl: string; /** Description of the MCP server. */
+  serverDescription?: string; /** Headers for authentication, e.g. Authorization. */
+  headers?: Record<string, string>;
+}>;
+/**
+ * Built-in tools for the Responses API.
+ * Access via `dashscope.responses.tools`.
+ */
+declare const responsesTools: {
+  /**
+   * Web search tool. Allows the model to search the internet for up-to-date information.
+   *
+   * @see https://help.aliyun.com/zh/model-studio/web-search
+   */
+  webSearch: (args?: Parameters<typeof webSearchToolFactory>[0]) => _$_ai_sdk_provider_utils0.Tool<Record<string, never>, {
+    query?: string;
+    sources?: Array<{
+      type: "url";
+      url: string;
+    }>;
+  }>;
+  /**
+   * Code interpreter tool. Allows the model to write and execute code.
+   *
+   * @see https://help.aliyun.com/zh/model-studio/qwen-code-interpreter
+   */
+  codeInterpreter: (args?: Parameters<typeof codeInterpreterToolFactory>[0]) => _$_ai_sdk_provider_utils0.Tool<Record<string, never>, {
+    code?: string;
+    outputs?: Array<{
+      type: "logs";
+      logs?: string;
+    }>;
+  }>;
+  /**
+   * Web extractor tool. Allows the model to access and extract content from web pages.
+   * Must be used together with webSearch.
+   *
+   * @see https://help.aliyun.com/zh/model-studio/web-extractor
+   */
+  webExtractor: (args?: Parameters<typeof webExtractorToolFactory>[0]) => _$_ai_sdk_provider_utils0.Tool<Record<string, never>, {
+    urls?: string[];
+    goal?: string;
+    output?: string;
+  }>;
+  /**
+   * File search tool. Search within uploaded or associated knowledge bases.
+   *
+   * @see https://help.aliyun.com/zh/model-studio/file-search
+   */
+  fileSearch: (args: Parameters<typeof fileSearchToolFactory>[0]) => _$_ai_sdk_provider_utils0.Tool<Record<string, never>, {
+    queries?: string[];
+    results?: Array<{
+      fileId?: string;
+      filename?: string;
+      score?: number;
+      text?: string;
+    }>;
+  }>;
+  /**
+   * Text-to-image search. Search images based on text description.
+   *
+   * @see https://help.aliyun.com/zh/model-studio/web-search-image
+   */
+  webSearchImage: (args?: Parameters<typeof webSearchImageToolFactory>[0]) => _$_ai_sdk_provider_utils0.Tool<Record<string, never>, {
+    queries?: string[];
+  }>;
+  /**
+   * Image-to-image search. Search similar images based on an input image.
+   *
+   * @see https://help.aliyun.com/zh/model-studio/image-search
+   */
+  imageSearch: (args?: Parameters<typeof imageSearchToolFactory>[0]) => _$_ai_sdk_provider_utils0.Tool<Record<string, never>, Record<string, never>>;
+  /**
+   * MCP (Model Context Protocol) tool. Allows calling external services via MCP.
+   *
+   * @see https://help.aliyun.com/zh/model-studio/mcp
+   */
+  mcp: (args: Parameters<typeof mcpToolFactory>[0]) => _$_ai_sdk_provider_utils0.Tool<Record<string, never>, Record<string, never>>;
+};
+type DashScopeResponsesTools = typeof responsesTools;
+//#endregion
+//#region src/types.d.ts
+type DashScopeRegion = "beijing" | "singapore" | "us" | "germany";
+declare const DASHSCOPE_REGION_BASE_URLS: Record<DashScopeRegion, {
+  baseURL: string;
+  videoBaseURL: string;
+}>;
+interface DashScopeProviderSettings {
+  apiKey?: string;
+  region?: DashScopeRegion;
+  workspaceId?: string;
+  baseURL?: string;
+  videoBaseURL?: string;
+  headers?: Record<string, string>;
+  fetch?: FetchFunction;
+  includeUsage?: boolean;
+}
+interface DashScopeChatOptions {
+  /** Enable thinking/reasoning mode. */
+  enableThinking?: boolean;
+  /** Maximum reasoning tokens. */
+  thinkingBudget?: number;
+  /** Enable parallel tool calls. */
+  parallelToolCalls?: boolean;
+  /** Enable web search. */
+  enableSearch?: boolean;
+  /**
+   * Search strategy.
+   * - "enable": enable search
+   * - "enable_with_history": enable search with history context
+   * - "agent_max": enable web extraction (requires enableSearch + enableThinking)
+   */
+  searchStrategy?: "enable" | "enable_with_history" | "agent_max";
+  /** Enable code interpreter (requires enableThinking). */
+  enableCodeInterpreter?: boolean;
+}
+interface DashScopeChatConfig {
+  provider: string;
+  baseURL: string;
+  headers: () => Record<string, string>;
+  fetch?: FetchFunction;
+  includeUsage?: boolean;
+}
+interface DashScopeResponsesOptions {
+  enableThinking?: boolean;
+  reasoning?: {
+    effort: "none" | "minimal" | "low" | "medium" | "high";
+  };
+  previousResponseId?: string;
+  conversation?: string;
+  instructions?: string;
+  includeUsage?: boolean;
+}
+interface DashScopeResponsesNamespace {
+  (modelId: string): LanguageModelV3;
+  tools: DashScopeResponsesTools;
+}
+interface DashScopeProvider {
+  (modelId: string): LanguageModelV3;
+  languageModel(modelId: string): LanguageModelV3;
+  chatOptions: (options: DashScopeChatOptions) => {
+    providerOptions: {
+      dashscope: DashScopeChatOptions;
+    };
+  };
+  responsesOptions: (options: DashScopeResponsesOptions) => {
+    providerOptions: {
+      dashscope: DashScopeResponsesOptions;
+    };
+  };
+  responses: DashScopeResponsesNamespace;
+}
+//#endregion
+//#region src/provider.d.ts
+declare function createDashScope(options?: DashScopeProviderSettings): DashScopeProvider;
+//#endregion
+//#region src/index.d.ts
+declare const dashscope: DashScopeProvider;
+//#endregion
+export { DASHSCOPE_REGION_BASE_URLS, DashScopeChatConfig, DashScopeChatOptions, DashScopeProvider, DashScopeProviderSettings, DashScopeRegion, DashScopeResponsesNamespace, DashScopeResponsesOptions, DashScopeResponsesTools, createDashScope, dashscope, responsesTools };