鸿蒙HarmonyOS NEXT AI对话实战——从0到1用ArkTS接入蓝耘MaaS，给礼物App装上多轮选礼大脑

curl -X POST "https://maas-api.lanyun.net/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $LANYUN_API_KEY" \
  -d '{
    "model": "deepseek-v3.2",
    "messages": [
      {"role": "system", "content": "你是礼物推荐助手。"},
      {"role": "user", "content": "预算500，送给喜欢摄影的女朋友，请给3个方向。"}
    ],
    "max_tokens": 1200,
    "temperature": 0.7,
    "stream": false
  }'

// server.mjs
import express from 'express';

const app = express();
app.use(express.json({ limit: '64kb' }));

const MAAS_URL = 'https://maas-api.lanyun.net/v1/chat/completions';
const API_KEY = process.env.LANYUN_API_KEY;
const DEFAULT_MODEL = process.env.LANYUN_MODEL || 'deepseek-v3.2';

const ALLOWED_MODELS = new Set([
  DEFAULT_MODEL,
  // 继续加入你在模型广场中确认可用的模型 ID
]);

const SYSTEM_PROMPT = `
你是一个礼物推荐助手。
目标：根据收礼人关系、场合、预算、兴趣和禁忌，逐步缩小候选。
规则：
1. 信息明显不足时先追问，不要硬猜。
2. 每次推荐优先给 3 个不同方向，而不是堆很多相似商品。
3. 每个方向说明：适合原因、参考预算、可能踩坑、如何进一步个性化。
4. 价格只能作为参考区间，不声称实时库存或实时价格。
5. 用户修改预算、对象或禁忌后，后续回答必须采用新约束。
6. 不主动要求身份证号、精确住址等与送礼无关的敏感信息。
`;

app.post('/api/ai/chat', async (req, res) => {
  const { model = DEFAULT_MODEL, messages = [] } = req.body ?? {};

  if (!ALLOWED_MODELS.has(model)) {
    return res.status(400).json({ code: 'MODEL_NOT_ALLOWED', message: '模型未开放' });
  }
  if (!Array.isArray(messages) || messages.length === 0) {
    return res.status(400).json({ code: 'BAD_MESSAGES', message: '消息不能为空' });
  }

  const safeMessages = messages
    .slice(-12)
    .filter(m => ['user', 'assistant'].includes(m?.role))
    .map(m => ({ role: m.role, content: String(m.content ?? '').slice(0, 4000) }));

  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), 85000);

  try {
    const upstream = await fetch(MAAS_URL, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${API_KEY}`,
      },
      body: JSON.stringify({
        model,
        messages: [{ role: 'system', content: SYSTEM_PROMPT }, ...safeMessages],
        max_tokens: 1600,
        temperature: 0.7,
        stream: false,
      }),
      signal: controller.signal,
    });

    const payload = await upstream.json();

    if (!upstream.ok) {
      return res.status(upstream.status).json({
        code: 'UPSTREAM_ERROR',
        message: payload?.error?.message || '模型服务调用失败',
      });
    }

    const msg = payload?.choices?.[0]?.message ?? {};
    const text = msg.content || msg.reasoning_content || '';

    if (!text) {
      return res.status(502).json({ code: 'EMPTY_REPLY', message: '模型返回为空' });
    }

    return res.json({
      text,
      usage: payload?.usage ?? null,
      model,
    });
  } catch (err) {
    const timeout = err?.name === 'AbortError';
    return res.status(timeout ? 504 : 502).json({
      code: timeout ? 'TIMEOUT' : 'GATEWAY_ERROR',
      message: timeout ? '模型响应超时' : '网关请求失败',
    });
  } finally {
    clearTimeout(timer);
  }
});

app.listen(3000, () => console.log('AI gateway listening on :3000'));

entry/src/main/ets/
├── common/
│   ├── ai/
│   │   ├── GiftModels.ets          // 模型配置
│   │   ├── ContextBuilder.ets      // 多轮上下文窗口
│   │   └── GatewayClient.ets       // 调用自有网关
│   └── model/
│       └── ChatModels.ets          // 消息与响应类型
├── pages/
│   ├── HomeTab.ets                 // AI 快捷入口
│   └── AITab.ets                   // 对话页
└── entryability/
    └── EntryAbility.ets

server/
└── server.mjs                      // 安全薄网关

{
  "module": {
    // ...
    "requestPermissions": [
      {
        "name": "ohos.permission.INTERNET"
      }
    ]
  }
}

// ChatModels.ets
export type ChatRole = 'user' | 'assistant';

export interface ChatMessage {
  role: ChatRole;
  content: string;
}

export interface UiMessage extends ChatMessage {
  id: number;
  loading: boolean;
  error?: boolean;
}

export interface TokenUsage {
  prompt_tokens?: number;
  completion_tokens?: number;
  total_tokens?: number;
}

export interface ChatResult {
  text: string;
  usage?: TokenUsage;
  model?: string;
}

export enum RequestState {
  IDLE = 'idle',
  SENDING = 'sending',
  SUCCESS = 'success',
  ERROR = 'error'
}

// ContextBuilder.ets
import { ChatMessage } from '../model/ChatModels';

export function buildContext(
  all: ChatMessage[],
  keepLast: number = 10,
  maxChars: number = 12000
): ChatMessage[] {
  const selected: ChatMessage[] = [];
  let used = 0;

  for (let i = all.length - 1; i >= 0; i--) {
    const msg = all[i];
    const text = msg.content.trim();
    if (text.length === 0) {
      continue;
    }

    // 当前消息优先，超出预算后停止继续向前装载
    if (selected.length > 0 && used + text.length > maxChars) {
      break;
    }

    selected.unshift({ role: msg.role, content: text });
    used += text.length;

    if (selected.length >= keepLast) {
      break;
    }
  }

  return selected;
}

// GatewayClient.ets
import { http } from '@kit.NetworkKit';
import { ChatMessage, ChatResult } from '../model/ChatModels';

const GATEWAY_URL = 'https://your-domain.example/api/ai/chat';

interface GatewayPayload {
  text?: string;
  model?: string;
  usage?: {
    prompt_tokens?: number;
    completion_tokens?: number;
    total_tokens?: number;
  };
  code?: string;
  message?: string;
}

export async function chat(
  messages: ChatMessage[],
  model: string
): Promise<ChatResult> {
  const client = http.createHttp();

  const timeoutPromise = new Promise<ChatResult>((_, reject) => {
    setTimeout(() => reject(new Error('TIMEOUT')), 90000);
  });

  const requestPromise = new Promise<ChatResult>(async (resolve, reject) => {
    try {
      const options: http.HttpRequestOptions = {
        method: http.RequestMethod.POST,
        header: {
          'Content-Type': 'application/json'
          // 如业务已有用户登录，在这里带你自己的短期用户令牌。
        },
        extraData: JSON.stringify({
          model,
          messages
        }),
        expectDataType: http.HttpDataType.STRING,
        connectTimeout: 20000,
        readTimeout: 85000
      };

      const response = await client.request(GATEWAY_URL, options);
      const body = JSON.parse(`${response.result}`) as GatewayPayload;

      if (response.responseCode < 200 || response.responseCode >= 300) {
        reject(new Error(body.code ?? `HTTP_${response.responseCode}`));
        return;
      }

      const text = (body.text ?? '').trim();
      if (text.length === 0) {
        reject(new Error('EMPTY_REPLY'));
        return;
      }

      resolve({
        text,
        usage: body.usage,
        model: body.model
      });
    } catch (e) {
      reject(e);
    }
  });

  try {
    return await Promise.race([requestPromise, timeoutPromise]);
  } finally {
    // 每个 HttpRequest 对象用完必须释放，避免长时间聊天产生资源堆积。
    client.destroy();
  }
}

@State private messages: UiMessage[] = [];
@State private inputText: string = '';
@State private requestState: RequestState = RequestState.IDLE;
@State private currentModelIndex: number = 0;

private messageId: number = 0;
private scroller: Scroller = new Scroller();

@Builder
MessageBubble(m: UiMessage) {
  Row() {
    if (m.role === 'assistant') {
      Column() {
        if (m.loading) {
          Row({ space: 8 }) {
            LoadingProgress().width(18).height(18)
            Text('正在整理礼物方案…').fontSize(13)
          }
          .padding(12)
          .backgroundColor('#EEF5FF')
          .borderRadius(16)
        } else {
          Text(m.content)
            .fontSize(14)
            .lineHeight(23)
            .fontColor(m.error ? '#A33A3A' : '#24384B')
            .padding(12)
            .backgroundColor(m.error ? '#FFF0F0' : '#EEF5FF')
            .borderRadius(16)
        }
      }.constraintSize({ maxWidth: '82%' })
      Blank().layoutWeight(1)
    } else {
      Blank().layoutWeight(1)
      Text(m.content)
        .fontSize(14)
        .lineHeight(23)
        .fontColor('#FFFFFF')
        .padding(12)
        .backgroundColor('#F28A3A')
        .borderRadius(16)
        .constraintSize({ maxWidth: '82%' })
    }
  }
  .width('100%')
  .padding({ left: 12, right: 12, top: 5, bottom: 5 })
}

private async doSend(raw: string): Promise<void> {
  const text = raw.trim();
  if (text.length === 0 || this.requestState === RequestState.SENDING) {
    return;
  }

  this.requestState = RequestState.SENDING;
  this.inputText = '';

  const userMsg: UiMessage = {
    id: ++this.messageId,
    role: 'user',
    content: text,
    loading: false
  };
  this.messages.push(userMsg);

  const aiId = ++this.messageId;
  this.messages.push({
    id: aiId,
    role: 'assistant',
    content: '',
    loading: true
  });
  this.messages = [...this.messages];
  this.scrollToBottom();

  const history: ChatMessage[] = this.messages
    .filter(m => !m.loading && !m.error && m.content.length > 0)
    .map(m => ({ role: m.role, content: m.content }));

  try {
    const context = buildContext(history, 10, 12000);
    const model = GIFT_MODELS[this.currentModelIndex].id;
    const result = await chat(context, model);

    this.replaceMessage(aiId, {
      id: aiId,
      role: 'assistant',
      content: result.text,
      loading: false
    });
    this.requestState = RequestState.SUCCESS;
  } catch (e) {
    this.replaceMessage(aiId, {
      id: aiId,
      role: 'assistant',
      content: this.friendlyError(e as Error),
      loading: false,
      error: true
    });
    this.requestState = RequestState.ERROR;
  }

  this.scrollToBottom();
}

private replaceMessage(id: number, next: UiMessage): void {
  const index = this.messages.findIndex(m => m.id === id);
  if (index >= 0) {
    this.messages.splice(index, 1, next);
    this.messages = [...this.messages];
  }
}

private scrollToBottom(): void {
  setTimeout(() => {
    if (this.messages.length > 0) {
      this.scroller.scrollToIndex(
        this.messages.length - 1,
        true,
        ScrollAlign.END
      );
    }
  }, 0);
}

// GiftModels.ets
export interface GiftModel {
  id: string;
  name: string;
  tip: string;
}

export const GIFT_MODELS: GiftModel[] = [
  {
    id: 'deepseek-v3.2',
    name: '均衡模型',
    tip: '复杂选礼、需要解释取舍时优先'
  },
  {
    id: 'deepseek-v3',
    name: '快速模型',
    tip: '短问答、贺卡文案、快速补充建议'
  }
  // 继续加入你在模型广场确认可用的 Qwen / Kimi / GLM / MiniMax 等模型 ID
];

// HomeTab.ets
function goAIWithPrompt(prompt: string): void {
  AppStorage.setOrCreate('giftAiPresetPrompt', prompt);
  AppStorage.setOrCreate('currentTab', 1);
}

// AITab.ets
@StorageLink('giftAiPresetPrompt')
private presetPrompt: string = '';

aboutToAppear(): void {
  if (this.presetPrompt.trim().length > 0) {
    this.inputText = this.presetPrompt;
    this.presetPrompt = '';
  }
}

private friendlyError(error: Error): string {
  const code = error.message;

  if (code === 'TIMEOUT') {
    return '这次思考时间有点长，已停止等待。你可以重试，或切换到更快的模型。';
  }
  if (code === 'EMPTY_REPLY') {
    return '模型这次没有返回有效内容，保留当前对话后可直接重试。';
  }
  if (code.includes('429')) {
    return '请求有点密集，请稍后再试。';
  }
  if (code.includes('401') || code.includes('403')) {
    return 'AI 服务暂时不可用，请稍后再试。';
  }
  return '网络或模型服务出现异常，本轮消息已保留，可以直接重试。';
}

{
  "recommendations": [
    {
      "title": "定制摄影体验",
      "reason": "兼顾摄影兴趣与纪念意义",
      "budgetRange": "300-500",
      "risk": "需要提前预约，注意时间安排",
      "personalizeTip": "加入两人的照片或纪念日期"
    }
  ]
}