SDK TypeScript

npm install @qwen-code/sdk

import { query } from '@qwen-code/sdk';
 
// Requête à un seul tour
const result = query({
  prompt: 'Quels fichiers se trouvent dans le répertoire actuel ?',
  options: {
    cwd: '/chemin/vers/projet',
  },
});
 
// Parcourir les messages
for await (const message of result) {
  if (message.type === 'assistant') {
    console.log('Assistant :', message.message.content);
  } else if (message.type === 'result') {
    console.log('Résultat :', message.result);
  }
}

const query = qwen.query('Votre prompt', {
  timeout: {
    canUseTool: 60000, // 60 secondes pour le callback de permission
    mcpRequest: 600000, // 10 minutes pour les appels d'outils MCP
    controlRequest: 60000, // 60 secondes pour les requêtes de contrôle
    streamClose: 15000, // 15 secondes pour l'attente de fermeture du flux
  },
});

import {
  isSDKUserMessage,
  isSDKAssistantMessage,
  isSDKSystemMessage,
  isSDKResultMessage,
  isSDKPartialAssistantMessage,
} from '@qwen-code/sdk';
 
for await (const message of result) {
  if (isSDKAssistantMessage(message)) {
    // Gérer un message de l'assistant
  } else if (isSDKResultMessage(message)) {
    // Gérer un message de résultat
  }
}

const q = query({ prompt: 'Bonjour', options: {} });
 
// Obtenir l'ID de session
const sessionId = q.getSessionId();
 
// Vérifier si fermée
const closed = q.isClosed();
 
// Interrompre l'opération en cours
await q.interrupt();
 
// Changer le mode de permission en cours de session
await q.setPermissionMode('yolo');
 
// Changer le modèle en cours de session
await q.setModel('qwen-max');
 
// Obtenir la répartition de l'utilisation de la fenêtre de contexte (nombre de tokens par catégorie)
const usage = await q.getContextUsage();
// Passer true pour indiquer que les détails par élément doivent être affichés
const detail = await q.getContextUsage(true);
 
// Fermer la session
await q.close();

import { query, type SDKUserMessage } from '@qwen-code/sdk';
 
async function* generateMessages(): AsyncIterable<SDKUserMessage> {
  yield {
    type: 'user',
    session_id: 'ma-session',
    message: { role: 'user', content: 'Crée un fichier hello.txt' },
    parent_tool_use_id: null,
  };
 
  // Attendre une condition ou une entrée utilisateur
  yield {
    type: 'user',
    session_id: 'ma-session',
    message: { role: 'user', content: 'Maintenant, lis le fichier' },
    parent_tool_use_id: null,
  };
}
 
const result = query({
  prompt: generateMessages(),
  options: {
    permissionMode: 'auto-edit',
  },
});
 
for await (const message of result) {
  console.log(message);
}

import { query, type CanUseTool } from '@qwen-code/sdk';
 
const canUseTool: CanUseTool = async (toolName, input, { signal }) => {
  // Autoriser toutes les opérations de lecture
  if (toolName.startsWith('read_')) {
    return { behavior: 'allow', updatedInput: input };
  }
 
  // Demander à l'utilisateur pour les opérations d'écriture (dans une vraie application)
  const userApproved = await promptUser(`Autoriser ${toolName} ?`);
 
  if (userApproved) {
    return { behavior: 'allow', updatedInput: input };
  }
 
  return { behavior: 'deny', message: 'L\'utilisateur a refusé l\'opération' };
};
 
const result = query({
  prompt: 'Crée un nouveau fichier',
  options: {
    canUseTool,
  },
});

import { query } from '@qwen-code/sdk';
 
const result = query({
  prompt: 'Utilise l\'outil personnalisé de mon serveur MCP',
  options: {
    mcpServers: {
      'mon-serveur': {
        command: 'node',
        args: ['chemin/vers/mcp-server.js'],
        env: { PORT: '3000' },
      },
    },
  },
});

import { query } from '@qwen-code/sdk';
 
const result = query({
  prompt: 'Dis bonjour en une phrase.',
  options: {
    systemPrompt: 'Tu es un assistant concis. Réponds exactement en une phrase.',
  },
});

import { query } from '@qwen-code/sdk';
 
const result = query({
  prompt: 'Examine le répertoire actuel.',
  options: {
    systemPrompt: {
      type: 'preset',
      preset: 'qwen_code',
      append: 'Sois concis et concentre-toi sur les constats concrets.',
    },
  },
});

{
  content: Array<
    | { type: 'text'; text: string }
    | { type: 'image'; data: string; mimeType: string }
    | { type: 'resource'; uri: string; mimeType?: string; text?: string }
  >;
  isError?: boolean;
}

import { z } from 'zod';
import { query, tool, createSdkMcpServer } from '@qwen-code/sdk';
 
// Define a tool with Zod schema
const calculatorTool = tool(
  'calculate_sum',
  'Add two numbers',
  { a: z.number(), b: z.number() },
  async (args) => ({
    content: [{ type: 'text', text: String(args.a + args.b) }],
  }),
);
 
// Create the MCP server
const server = createSdkMcpServer({
  name: 'calculator',
  tools: [calculatorTool],
});
 
// Use the server in a query
const result = query({
  prompt: 'What is 42 + 17?',
  options: {
    permissionMode: 'yolo',
    mcpServers: {
      calculator: server,
    },
  },
});
 
for await (const message of result) {
  console.log(message);
}

import { query, isAbortError } from '@qwen-code/sdk';
 
const abortController = new AbortController();
 
const result = query({
  prompt: 'Long running task...',
  options: {
    abortController,
  },
});
 
// Abort after 5 seconds
setTimeout(() => abortController.abort(), 5000);
 
try {
  for await (const message of result) {
    console.log(message);
  }
} catch (error) {
  if (isAbortError(error)) {
    console.log('Query was aborted');
  } else {
    throw error;
  }
}

import { AbortError, isAbortError } from '@qwen-code/sdk';
 
try {
  // ... query operations
} catch (error) {
  if (isAbortError(error)) {
    // Handle abort
  } else {
    // Handle other errors
  }
}