seacloud-sdk 0.5.0 → 0.6.0

package/dist/cli.js

@@ -144,36 +144,379 @@ var SeacloudClient = class {
     return { ...this.config };
   }
 };
+
+// src/core/global-config.ts
+var globalConfig = {
+  client: null,
+  defaultPollingOptions: {
+    intervalMs: 3e3,
+    // 3秒轮询间隔
+    maxAttempts: 100
+    // 最多尝试100次 (约5分钟)
+  }
+};
+function initSeacloud(apiKey, options) {
+  if (!apiKey) {
+    throw new Error("API key is required. Please provide a valid API key.");
+  }
+  globalConfig.client = new SeacloudClient({
+    apiKey,
+    baseUrl: options?.baseUrl,
+    timeout: options?.timeout
+  });
+  if (options?.intervalMs !== void 0) {
+    globalConfig.defaultPollingOptions.intervalMs = options.intervalMs;
+  }
+  if (options?.maxAttempts !== void 0) {
+    globalConfig.defaultPollingOptions.maxAttempts = options.maxAttempts;
+  }
+  return globalConfig.client;
+}
+function getClient() {
+  if (!globalConfig.client) {
+    throw new Error(
+      "SeaCloud SDK is not initialized. Please call initSeacloud(apiKey) first."
+    );
+  }
+  return globalConfig.client;
+}
+
+// src/api/llm_chat_completions.ts
+async function llmChatCompletions(params) {
+  const client = getClient();
+  const config = client.getConfig();
+  const url = `${config.baseUrl}/llm/chat/completions`;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), config.timeout);
+  try {
+    const response = await config.fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${config.apiKey}`
+      },
+      body: JSON.stringify(params),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new SeacloudError(
+        `HTTP ${response.status}: ${errorBody}`,
+        response.status,
+        errorBody
+      );
+    }
+    if (params.stream) {
+      return parseStreamingResponse(response);
+    }
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof SeacloudError) {
+      throw error;
+    }
+    if (error.name === "AbortError") {
+      throw new SeacloudError(`Request timeout after ${config.timeout}ms`);
+    }
+    throw new SeacloudError(
+      `Request failed: ${error.message}`,
+      void 0,
+      error
+    );
+  }
+}
+async function* parseStreamingResponse(response) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new SeacloudError("Response body is not readable");
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine) continue;
+        if (trimmedLine === "data: [DONE]") continue;
+        if (trimmedLine.startsWith("data: ")) {
+          const jsonStr = trimmedLine.slice(6);
+          try {
+            const chunk = JSON.parse(jsonStr);
+            yield chunk;
+          } catch (error) {
+            console.warn("Failed to parse SSE chunk:", jsonStr);
+          }
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/api/agent_chat_completions.ts
+async function agentChatCompletions(params) {
+  const client = getClient();
+  const config = client.getConfig();
+  const url = `${config.baseUrl}/agent/api/v1/chat/completions`;
+  const model = params.model || "custom_openai/vertex-ai-claude-sonnet-4.5";
+  const userWantsStreaming = params.stream !== false;
+  const requestBody = {
+    ...params,
+    model,
+    stream: true
+    // Always request SSE from API
+  };
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), config.timeout);
+  try {
+    const response = await config.fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${config.apiKey}`,
+        "X-Project": "SeaArt"
+        // Required header for agent API
+      },
+      body: JSON.stringify(requestBody),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new SeacloudError(
+        `HTTP ${response.status}: ${errorBody}`,
+        response.status,
+        errorBody
+      );
+    }
+    if (userWantsStreaming) {
+      return parseAgentStreamingResponse(response);
+    }
+    return await parseAgentNonStreamingResponse(response);
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof SeacloudError) {
+      throw error;
+    }
+    if (error.name === "AbortError") {
+      throw new SeacloudError(`Request timeout after ${config.timeout}ms`);
+    }
+    throw new SeacloudError(
+      `Request failed: ${error.message}`,
+      void 0,
+      error
+    );
+  }
+}
+async function parseAgentNonStreamingResponse(response) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new SeacloudError("Response body is not readable");
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let fullContent = "";
+  let artifacts = [];
+  let finishReason = "";
+  let sessionId = "";
+  let msgId = "";
+  let lastChunk = null;
+  let usage;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine) continue;
+        if (trimmedLine === "data: [DONE]") continue;
+        if (trimmedLine === "event: heartbeat") continue;
+        if (trimmedLine.startsWith("data: ")) {
+          const data = trimmedLine.slice(6).trim();
+          try {
+            const parsed = JSON.parse(data);
+            lastChunk = parsed;
+            const delta = parsed.choices?.[0]?.delta;
+            if (delta?.content) {
+              if (typeof delta.content === "string") {
+                fullContent += delta.content;
+              } else if (Array.isArray(delta.content)) {
+                for (const item of delta.content) {
+                  if (item.type === "text" && item.text) {
+                    fullContent += item.text;
+                  }
+                }
+              }
+            }
+            if (delta?.artifacts) {
+              artifacts.push(...delta.artifacts);
+            }
+            if (parsed.choices?.[0]?.finish_reason) {
+              finishReason = parsed.choices[0].finish_reason;
+            }
+            if (parsed.session_id) {
+              sessionId = parsed.session_id;
+            }
+            if (parsed.msg_id) {
+              msgId = parsed.msg_id;
+            }
+            if (parsed.usage) {
+              usage = parsed.usage;
+            }
+          } catch (e) {
+            console.warn("Failed to parse SSE chunk:", data.substring(0, 100));
+          }
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  if (!lastChunk) {
+    throw new SeacloudError("No valid response chunks received");
+  }
+  return {
+    id: lastChunk.id,
+    object: "chat.completion",
+    created: lastChunk.created,
+    model: lastChunk.model,
+    system_fingerprint: lastChunk.system_fingerprint,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          content: fullContent
+        },
+        finish_reason: finishReason || null
+      }
+    ],
+    usage,
+    session_id: sessionId || void 0,
+    msg_id: msgId || void 0,
+    artifacts: artifacts.length > 0 ? artifacts : void 0
+  };
+}
+async function* parseAgentStreamingResponse(response) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new SeacloudError("Response body is not readable");
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine || trimmedLine.startsWith(":")) continue;
+        if (trimmedLine.startsWith("event: ")) {
+          const eventType = trimmedLine.slice(7).trim();
+          if (eventType === "heartbeat") {
+            continue;
+          }
+        }
+        if (trimmedLine.startsWith("data: ")) {
+          const data = trimmedLine.slice(6).trim();
+          if (data === "[DONE]") {
+            break;
+          }
+          try {
+            const chunk = JSON.parse(data);
+            yield chunk;
+          } catch (error) {
+            console.warn("Failed to parse SSE chunk:", data);
+          }
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function createTextMessage(role, text) {
+  return {
+    role,
+    content: [{ type: "text", text }]
+  };
+}
 var __filename$1 = fileURLToPath(import.meta.url);
 dirname(__filename$1);
 function showHelp() {
   console.log(`
-SeaCloud CLI - Test AI models from command line
+SeaCloud CLI - Test AI models, LLM, and Agent from command line
 
 Usage:
-  seacloud <model> [options]
+  seacloud <command> [options]
+
+Commands:
+  llm <prompt>         Chat with LLM models
+  agent <prompt>       Chat with Fast Agent (supports image/video generation)
+  <model>              Test specific model generation
 
-Options:
+LLM Options:
+  --model <name>       Model name (default: seaart-mix-sonnet-4-5)
+  --stream             Enable streaming mode
+  --temperature <n>    Temperature 0-2 (default: 0.7)
+  --max-tokens <n>     Max tokens to generate
+
+Agent Options:
+  --agent-id <id>      Agent ID (default: seagen_agent)
+  --model <name>       Model name (default: gpt-4o)
+  --stream             Enable streaming mode
+  --session-id <id>    Session ID for multi-turn conversation
+
+Model Generation Options:
   --api-key <key>      API key (or set API_SERVICE_TOKEN env var)
-  --base-url <url>     Base URL (or set API_BASE_URL env var)
+  --base-url <url>     Base URL (default: http://proxy.sg.seaverse.dev)
   --params <json>      JSON parameters for the model
 
 Examples:
-  # Test mureka song generator
-  seacloud mureka_song_generator --params '{"lyrics":"Happy birthday","style":"pop"}'
+  # Chat with LLM (non-streaming)
+  seacloud llm "What is the capital of France?"
+
+  # Chat with LLM (streaming)
+  seacloud llm "Tell me a story" --stream
+
+  # Chat with LLM using specific model
+  seacloud llm "Hello" --model deepseek-v3.1 --temperature 1.0
 
-  # Test minimax TTS
-  seacloud minimax_tts --params '{"text":"Hello world","voice_id":"male-qn-qingse"}'
+  # Chat with Agent (can generate images)
+  seacloud agent "Generate an image of a sunset"
 
-  # Test flux image generation
+  # Chat with Agent (streaming)
+  seacloud agent "Create a cat image" --stream
+
+  # Test model generation
   seacloud flux_1_1_pro --params '{"prompt":"a beautiful sunset"}'
 
-  # Use custom API key and base URL
-  seacloud flux_1_1_pro --api-key sa-xxx --base-url http://localhost:8080 --params '{"prompt":"test"}'
+  # Use custom API key
+  seacloud llm "Hello" --api-key sa-xxx
 
 Environment Variables:
-  API_SERVICE_TOKEN    API authentication token
-  API_BASE_URL         Base URL for API endpoints
+  API_SERVICE_TOKEN    API authentication token (required)
+  SEACLOUD_BASE_URL    Base URL for API endpoints
 `);
 }
 function parseArgs(args) {
@@ -277,20 +620,151 @@ async function testModel(model, options) {
     process.exit(1);
   }
 }
+async function runLlm(prompt, args) {
+  const options = { stream: false, model: "seaart-mix-sonnet-4-5", temperature: 0.7 };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--model") options.model = args[++i];
+    else if (arg === "--stream") options.stream = true;
+    else if (arg === "--temperature") options.temperature = parseFloat(args[++i]);
+    else if (arg === "--max-tokens") options.maxTokens = parseInt(args[++i]);
+    else if (arg === "--api-key") options.apiKey = args[++i];
+    else if (arg === "--base-url") options.baseUrl = args[++i];
+  }
+  const apiKey = options.apiKey || process.env.API_SERVICE_TOKEN;
+  const baseUrl = options.baseUrl || process.env.SEACLOUD_BASE_URL || "http://proxy.sg.seaverse.dev";
+  if (!apiKey) {
+    console.error("Error: API key not provided. Use --api-key or set API_SERVICE_TOKEN env var");
+    process.exit(1);
+  }
+  initSeacloud(apiKey, { baseUrl, timeout: 12e4 });
+  console.log(`Model: ${options.model}`);
+  console.log(`Prompt: ${prompt}
+`);
+  if (options.stream) {
+    const stream = await llmChatCompletions({
+      model: options.model,
+      messages: [{ role: "user", content: prompt }],
+      stream: true,
+      temperature: options.temperature,
+      max_tokens: options.maxTokens
+    });
+    process.stdout.write("Response: ");
+    for await (const chunk of stream) {
+      const content = chunk.choices[0]?.delta?.content;
+      if (typeof content === "string") process.stdout.write(content);
+    }
+    console.log("\n");
+  } else {
+    const response = await llmChatCompletions({
+      model: options.model,
+      messages: [{ role: "user", content: prompt }],
+      stream: false,
+      temperature: options.temperature,
+      max_tokens: options.maxTokens
+    });
+    console.log("Response:", response.choices[0].message.content);
+    console.log("\nUsage:", response.usage);
+  }
+}
+async function runAgent(prompt, args) {
+  const options = {
+    stream: false,
+    model: "gpt-4o",
+    agentId: "seagen_agent"
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--model") options.model = args[++i];
+    else if (arg === "--stream") options.stream = true;
+    else if (arg === "--agent-id") options.agentId = args[++i];
+    else if (arg === "--session-id") options.sessionId = args[++i];
+    else if (arg === "--api-key") options.apiKey = args[++i];
+    else if (arg === "--base-url") options.baseUrl = args[++i];
+  }
+  const apiKey = options.apiKey || process.env.API_SERVICE_TOKEN;
+  const baseUrl = options.baseUrl || process.env.SEACLOUD_BASE_URL || "http://proxy.sg.seaverse.dev";
+  if (!apiKey) {
+    console.error("Error: API key not provided. Use --api-key or set API_SERVICE_TOKEN env var");
+    process.exit(1);
+  }
+  initSeacloud(apiKey, { baseUrl, timeout: 3e5 });
+  console.log(`Agent: ${options.agentId}`);
+  console.log(`Model: ${options.model}`);
+  console.log(`Prompt: ${prompt}
+`);
+  if (options.stream) {
+    const stream = await agentChatCompletions({
+      agent_id: options.agentId,
+      messages: [createTextMessage("user", prompt)],
+      model: options.model,
+      stream: true,
+      session_id: options.sessionId,
+      seq: 0
+    });
+    process.stdout.write("Response: ");
+    for await (const chunk of stream) {
+      const content = chunk.choices[0]?.delta?.content;
+      if (typeof content === "string") process.stdout.write(content);
+    }
+    console.log("\n");
+  } else {
+    const response = await agentChatCompletions({
+      agent_id: options.agentId,
+      messages: [createTextMessage("user", prompt)],
+      model: options.model,
+      stream: false,
+      session_id: options.sessionId,
+      seq: 0
+    });
+    console.log("Response:", response.choices[0].message.content);
+    if (response.artifacts && response.artifacts.length > 0) {
+      console.log("\nGenerated Artifacts:");
+      response.artifacts.forEach((artifact, i) => {
+        console.log(`  ${i + 1}. ${artifact.name}`);
+        console.log(`     URL: ${artifact.url}`);
+      });
+    }
+    console.log("\nSession ID:", response.session_id);
+    console.log("Message ID:", response.msg_id);
+  }
+}
 async function main() {
   const args = process.argv.slice(2);
   if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
     showHelp();
     process.exit(0);
   }
-  const model = args[0];
-  if (model.startsWith("--")) {
-    console.error("Error: model name required");
-    console.log("Usage: seacloud <model> --params <json>");
+  const command = args[0];
+  try {
+    if (command === "llm") {
+      if (args.length < 2) {
+        console.error("Error: prompt required for llm command");
+        console.log('Usage: seacloud llm "<prompt>" [options]');
+        process.exit(1);
+      }
+      await runLlm(args[1], args.slice(2));
+    } else if (command === "agent") {
+      if (args.length < 2) {
+        console.error("Error: prompt required for agent command");
+        console.log('Usage: seacloud agent "<prompt>" [options]');
+        process.exit(1);
+      }
+      await runAgent(args[1], args.slice(2));
+    } else {
+      const model = command;
+      if (model.startsWith("--")) {
+        console.error("Error: command or model name required");
+        console.log("Usage: seacloud <command> [options]");
+        process.exit(1);
+      }
+      const options = parseArgs(args.slice(1));
+      await testModel(model, options);
+    }
+  } catch (error) {
+    console.error("\nError:", error.message);
     process.exit(1);
   }
-  const options = parseArgs(args.slice(1));
-  await testModel(model, options);
 }
 main().catch(console.error);
 //# sourceMappingURL=cli.js.map