0G integration

async infer(messages): Promise<InferenceResult> {
  const broker = await this.getBroker();
  await this.ensureFunded(broker);

  const provider = this.config.computeProvider;
  const { endpoint, model } = await broker.inference.getServiceMetadata(provider);

  const content = serialize(messages);                               // joined role+content; the broker bills on it
  const headers = await broker.inference.getRequestHeaders(provider, content);  // SINGLE-USE per call

  const openai = new OpenAI({ baseURL: endpoint, apiKey: '' });
  // .withResponse() exposes raw headers: the TEE signature is keyed by the
  // provider's ZG-Res-Key header, NOT completion.id (which 404s).
  const { data: completion, response } = await openai.chat.completions
    .create({ model, messages }, { headers: { ...headers } })
    .withResponse();

  const answer = completion.choices[0]?.message?.content;
  if (!answer) throw new Error('0G inference returned an empty completion');

  const chatId = response.headers.get('ZG-Res-Key') ?? completion.id;   // the verification handle
  return { answer, chatId, provider, model };
}

async upload(bytes): Promise<UploadResult> {
  const data = new MemData(bytes);

  const [tree, treeErr] = await data.merkleTree();   // [result, err] TUPLE — never assume a throw
  if (treeErr !== null) throw treeErr;
  const expectedRoot = tree?.rootHash() ?? null;

  const [res, upErr] = await this.indexer.upload(data, this.evmRpc, signer);
  if (upErr !== null) throw upErr;

  // upload() is polymorphic: one small object returns { rootHash, txHash }; narrow defensively.
  const rootHash = 'rootHash' in res ? res.rootHash : res.rootHashes[0];
  if (expectedRoot !== null && rootHash !== expectedRoot)
    throw new Error('0G upload root mismatch');
  return { rootHash, txHash: res.txHash ?? null };
}

function commitMemory(bytes32 rootHash) external returns (uint256 index) {
  if (!registered[msg.sender]) revert NotRegistered();
  if (rootHash == bytes32(0))  revert ZeroRootHash();
  index = _memories[msg.sender].length;
  _memories[msg.sender].push(Commitment({ rootHash: rootHash, timestamp: uint64(block.timestamp) }));
  emit MemoryCommitted(msg.sender, rootHash, index);
}