JavaScript SDK

使用 inference.sh 的 JavaScript/TypeScript SDK 构建 AI 应用程序。

快速开始

npm install @inferencesh/sdk

import { inference } from '@inferencesh/sdk';

const client = inference({ apiKey: 'inf_your_key' });

// 运行一个 AI 应用
const result = await client.run({
  app: 'infsh/flux-schnell',
  input: { prompt: 'A sunset over mountains' }
});
console.log(result.output);

安装

npm install @inferencesh/sdk
# 或
yarn add @inferencesh/sdk
# 或
pnpm add @inferencesh/sdk

要求： Node.js 18.0.0+（或支持 fetch 的现代浏览器）

身份验证

import { inference } from '@inferencesh/sdk';

// 直接传入 API 密钥
const client = inference({ apiKey: 'inf_your_key' });

// 从环境变量读取（推荐）
const client = inference({ apiKey: process.env.INFERENCE_API_KEY });

// 前端应用（需通过代理）
const client = inference({ proxyUrl: '/api/inference/proxy' });

获取您的 API 密钥：设置 → API 密钥 → 创建 API 密钥

运行应用

基础执行

const result = await client.run({
  app: 'infsh/flux-schnell',
  input: { prompt: 'A cat astronaut' }
});

console.log(result.status);  // "completed"
console.log(result.output);  // 输出数据

即发即弃（Fire and Forget）

const task = await client.run({
  app: 'google/veo-3-1-fast',
  input: { prompt: 'Drone flying over mountains' }
}, { wait: false });

console.log(`Task ID: ${task.id}`);
// 后续可通过 client.getTask(task.id) 查询任务状态

流式进度更新

const stream = await client.run({
  app: 'google/veo-3-1-fast',
  input: { prompt: 'Ocean waves at sunset' }
}, { stream: true });

for await (const update of stream) {
  console.log(`Status: ${update.status}`);
  if (update.logs?.length) {
    console.log(update.logs.at(-1));
  }
}

运行参数

文件处理

自动上传

const result = await client.run({
  app: 'image-processor',
  input: {
    image: '/path/to/image.png'  // 自动上传
  }
});

手动上传

// 基础上传
const file = await client.uploadFile('/path/to/image.png');

// 指定选项上传
const file = await client.uploadFile('/path/to/image.png', {
  filename: 'custom_name.png',
  contentType: 'image/png',
  public: true
});

const result = await client.run({
  app: 'image-processor',
  input: { image: file.uri }
});

浏览器文件上传

const input = document.querySelector('input[type="file"]');
const file = await client.uploadFile(input.files[0]);

会话（有状态执行）

在多次调用间保持 Worker 热启动：

// 启动新会话
const result = await client.run({
  app: 'my-app',
  input: { action: 'init' },
  session: 'new',
  session_timeout: 300  // 5 分钟
});
const sessionId = result.session_id;

// 在同一会话中继续执行
const result2 = await client.run({
  app: 'my-app',
  input: { action: 'process' },
  session: sessionId
});

Agent SDK

模板 Agent

复用您工作区中预构建的 Agent：

const agent = client.agent('my-team/support-agent@latest');

// 发送消息
const response = await agent.sendMessage('Hello!');
console.log(response.text);

// 多轮对话
const response2 = await agent.sendMessage('Tell me more');

// 重置对话
agent.reset();

// 获取聊天历史
const chat = await agent.getChat();

临时 Agent（Ad-hoc Agents）

以编程方式创建自定义 Agent：

import { tool, string, number, appTool } from '@inferencesh/sdk';

// 定义工具
const calculator = tool('calculate')
  .describe('Perform a calculation')
  .param('expression', string('Math expression'))
  .build();

const imageGen = appTool('generate_image', 'infsh/flux-schnell@latest')
  .describe('Generate an image')
  .param('prompt', string('Image description'))
  .build();

// 创建 Agent
const agent = client.agent({
  core_app: { ref: 'infsh/claude-sonnet-4@latest' },
  system_prompt: 'You are a helpful assistant.',
  tools: [calculator, imageGen],
  temperature: 0.7,
  max_tokens: 4096
});

const response = await agent.sendMessage('What is 25 * 4?');

可用核心应用

工具构建器 API（Tool Builder API）

参数类型

import {
  string, number, integer, boolean,
  enumOf, array, obj, optional
} from '@inferencesh/sdk';

const name = string("User's name");
const age = integer('Age in years');
const score = number('Score 0-1');
const active = boolean('Is active');
const priority = enumOf(['low', 'medium', 'high'], 'Priority');
const tags = array(string('Tag'), 'List of tags');
const address = obj({
  street: string('Street'),
  city: string('City'),
  zip: optional(string('ZIP'))
}, 'Address');

客户端工具（在您的代码中运行）

const greet = tool('greet')
  .display('Greet User')
  .describe('Greets a user by name')
  .param('name', string('Name to greet'))
  .requireApproval()
  .build();

应用工具（调用 AI 应用）

const generate = appTool('generate_image', 'infsh/flux-schnell@latest')
  .describe('Generate an image from text')
  .param('prompt', string('Image description'))
  .setup({ model: 'schnell' })
  .input({ steps: 20 })
  .requireApproval()
  .build();

Agent 工具（委派给子 Agent）

import { agentTool } from '@inferencesh/sdk';

const researcher = agentTool('research', 'my-org/researcher@v1')
  .describe('Research a topic')
  .param('topic', string('Topic to research'))
  .build();

Webhook 工具（调用外部 API）

import { webhookTool } from '@inferencesh/sdk';

const notify = webhookTool('slack', 'https://hooks.slack.com/...')
  .describe('Send Slack notification')
  .secret('SLACK_SECRET')
  .param('channel', string('Channel'))
  .param('message', string('Message'))
  .build();

内置工具（Internal Tools）

import { internalTools } from '@inferencesh/sdk';

const config = internalTools()
  .plan()
  .memory()
  .webSearch(true)
  .codeExecution(true)
  .imageGeneration({
    enabled: true,
    appRef: 'infsh/flux@latest'
  })
  .build();

const agent = client.agent({
  core_app: { ref: 'infsh/claude-sonnet-4@latest' },
  internal_tools: config
});

流式 Agent 响应

const response = await agent.sendMessage('Explain quantum computing', {
  onMessage: (msg) => {
    if (msg.content) {
      process.stdout.write(msg.content);
    }
  },
  onToolCall: async (call) => {
    console.log(`\n[Tool: ${call.name}]`);
    const result = await executeTool(call.name, call.args);
    agent.submitToolResult(call.id, result);
  }
});

文件附件

// 从文件路径读取（Node.js）
import { readFileSync } from 'fs';
const response = await agent.sendMessage("What's in this image?", {
  files: [readFileSync('image.png')]
});

// 从 Base64 字符串读取
const response = await agent.sendMessage('Analyze this', {
  files: ['data:image/png;base64,iVBORw0KGgo...']
});

// 从浏览器 File 对象读取
const input = document.querySelector('input[type="file"]');
const response = await agent.sendMessage('Describe this', {
  files: [input.files[0]]
});

技能（Skills，可复用上下文）

const agent = client.agent({
  core_app: { ref: 'infsh/claude-sonnet-4@latest' },
  skills: [
    {
      name: 'code-review',
      description: 'Code review guidelines',
      content: '# Code Review\n\n1. Check security\n2. Check performance...\n'
    },
    {
      name: 'api-docs',
      description: 'API documentation',
      url: 'https://example.com/skills/api-docs.md'
    }
  ]
});

服务端代理（适用于前端应用）

对于浏览器端应用，请通过后端代理请求，以保障 API 密钥安全：

客户端配置

const client = inference({
  proxyUrl: '/api/inference/proxy'
  // 前端无需提供 apiKey
});

Next.js 代理（App Router）

// app/api/inference/proxy/route.ts
import { createRouteHandler } from '@inferencesh/sdk/proxy/nextjs';

const route = createRouteHandler({
  apiKey: process.env.INFERENCE_API_KEY
});

export const POST = route.POST;

Express 代理

import express from 'express';
import { createProxyMiddleware } from '@inferencesh/sdk/proxy/express';

const app = express();
app.use('/api/inference/proxy', createProxyMiddleware({
  apiKey: process.env.INFERENCE_API_KEY
}));

支持的框架

• Next.js（App Router 和 Pages Router）
• Express
• Hono
• Remix
• SvelteKit

TypeScript 支持

包含完整的类型定义：

import type {
  TaskDTO,
  ChatDTO,
  ChatMessageDTO,
  AgentTool,
  TaskStatusCompleted,
  TaskStatusFailed
} from '@inferencesh/sdk';

if (result.status === TaskStatusCompleted) {
  console.log('Done!');
} else if (result.status === TaskStatusFailed) {
  console.log('Failed:', result.error);
}

错误处理

import { RequirementsNotMetException, InferenceError } from '@inferencesh/sdk';

try {
  const result = await client.run({ app: 'my-app', input: {...} });
} catch (e) {
  if (e instanceof RequirementsNotMetException) {
    console.log('Missing requirements:');
    for (const err of e.errors) {
      console.log(`  - ${err.type}: ${err.key}`);
    }
  } else if (e instanceof InferenceError) {
    console.log('API error:', e.message);
  }
}

人工审批工作流

const response = await agent.sendMessage('Delete all temp files', {
  onToolCall: async (call) => {
    if (call.requiresApproval) {
      const approved = await promptUser(`Allow ${call.name}?`);
      if (approved) {
        const result = await executeTool(call.name, call.args);
        agent.submitToolResult(call.id, result);
      } else {
        agent.submitToolResult(call.id, { error: 'Denied by user' });
      }
    }
  }
});

CommonJS 支持

const { inference, tool, string } = require('@inferencesh/sdk');

const client = inference({ apiKey: 'inf_...' });
const result = await client.run({...});

参考文档

• Agent 模式 — 多 Agent、RAG、批量处理等模式
• 工具构建器 — 完整的工具构建器 API 参考
• 服务端代理 — Next.js、Express、Hono、Remix、SvelteKit 配置指南
• 流式传输 — 实时进度更新与 SSE 处理
• 文件处理 — 文件上传、下载与管理
• 会话 — 使用热 Worker 实现有状态执行
• TypeScript — 类型定义与类型安全实践
• React 集成 — Hooks、组件与最佳实践

相关技能

# Python SDK
npx skills add inference-sh/skills@python-sdk

# 全平台技能（通过 CLI 访问全部 150+ 个应用）
npx skills add inference-sh/skills@inference-sh

# LLM 模型
npx skills add inference-sh/skills@llm-models

# 图像生成
npx skills add inference-sh/skills@ai-image-generation

文档

• JavaScript SDK 参考 — 完整 API 文档
• Agent SDK 概览 — 构建 Agent 指南
• 工具构建器参考 — 创建工具说明
• 服务端代理配置 — 前端集成方案
• 身份验证 — API 密钥配置方法
• 流式传输 — 实时更新机制
• 文件上传 — 文件处理详解