Retrieve Results from Ambient Webhook

const BASE_URL = "https://sdp.suki.ai";
const AMBIENT_PATH = "/api/v1/ambient";
const HEADERS = { sdp_suki_token: "<sdp_suki_token>" };

type Link = {
  href: string;
  method: string;
  name: string;
  type: string;
};

function linkFor(
  links: Record<string, Link[]>,
  key: string,
  name: string
): Link | undefined {
  return (links[key] ?? []).find((link) => link.name === name);
}

export async function loadAmbientResults(payload: any) {
  const sessionId: string = payload.session_id;
  const links: Record<string, Link[]> = payload._links ?? {};

  const statusLink = linkFor(links, "status", sessionId);
  if (!statusLink) {
    throw new Error(`No status link found for session ${sessionId}`);
  }

  const statusRes = await fetch(BASE_URL + AMBIENT_PATH + statusLink.href, {
    headers: HEADERS,
  });
  if (!statusRes.ok) {
    throw new Error(`Status call failed: ${statusRes.status}`);
  }

  const { status } = await statusRes.json();
  if (status !== "completed") {
    console.log(`Session ${sessionId} is not completed: ${status}`);
    return null;
  }

  const contentLink = linkFor(links, "contents", sessionId);
  if (!contentLink) {
    throw new Error(`No content link found for session ${sessionId}`);
  }

  const contentRes = await fetch(BASE_URL + AMBIENT_PATH + contentLink.href, {
    headers: HEADERS,
  });
  if (!contentRes.ok) {
    throw new Error(`Content call failed: ${contentRes.status}`);
  }

  return contentRes.json();
}

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

const (
	baseURL     = "https://sdp.suki.ai"
	ambientPath = "/api/v1/ambient"
	sukiToken   = "<sdp_suki_token>"
)

type link struct {
	Href   string `json:"href"`
	Method string `json:"method"`
	Name   string `json:"name"`
	Type   string `json:"type"`
}

func linkFor(links map[string][]link, key, name string) (link, bool) {
	for _, item := range links[key] {
		if item.Name == name {
			return item, true
		}
	}
	return link{}, false
}

func getJSON(href string) (map[string]any, error) {
	req, err := http.NewRequest(http.MethodGet, baseURL+ambientPath+href, nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("sdp_suki_token", sukiToken)

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()

	body, err := io.ReadAll(res.Body)
	if err != nil {
		return nil, err
	}
	if res.StatusCode < 200 || res.StatusCode >= 300 {
		return nil, fmt.Errorf("request failed: %s", res.Status)
	}

	var payload map[string]any
	if err := json.Unmarshal(body, &payload); err != nil {
		return nil, err
	}
	return payload, nil
}

func loadAmbientResults(payload map[string]any) (map[string]any, error) {
	sessionID, _ := payload["session_id"].(string)
	rawLinks, _ := payload["_links"].(map[string]any)

	links := map[string][]link{}
	for key, value := range rawLinks {
		encoded, err := json.Marshal(value)
		if err != nil {
			return nil, err
		}
		var items []link
		if err := json.Unmarshal(encoded, &items); err != nil {
			return nil, err
		}
		links[key] = items
	}

	statusLink, ok := linkFor(links, "status", sessionID)
	if !ok {
		return nil, fmt.Errorf("no status link found for session %s", sessionID)
	}

	statusPayload, err := getJSON(statusLink.Href)
	if err != nil {
		return nil, err
	}

	status, _ := statusPayload["status"].(string)
	if status != "completed" {
		fmt.Printf("Session %s is not completed: %s\n", sessionID, status)
		return nil, nil
	}

	contentLink, ok := linkFor(links, "contents", sessionID)
	if !ok {
		return nil, fmt.Errorf("no content link found for session %s", sessionID)
	}

	return getJSON(contentLink.Href)
}

export async function loadTranscript(
  links: Record<string, Link[]>,
  sessionId: string
) {
  const transcriptLink = linkFor(links, "transcripts", sessionId);
  if (!transcriptLink) {
    throw new Error(`No transcript link found for session ${sessionId}`);
  }

  const response = await fetch(BASE_URL + AMBIENT_PATH + transcriptLink.href, {
    headers: HEADERS,
  });
  if (!response.ok) {
    throw new Error(`Transcript call failed: ${response.status}`);
  }
  return response.json();
}

func loadTranscript(links map[string][]link, sessionID string) (map[string]any, error) {
	transcriptLink, ok := linkFor(links, "transcripts", sessionID)
	if !ok {
		return nil, fmt.Errorf("no transcript link found for session %s", sessionID)
	}
	return getJSON(transcriptLink.Href)
}

export async function loadEncounterContent(links: Record<string, Link[]>) {
  const encounterLinks = links.encounter_content ?? [];
  if (!encounterLinks.length) {
    throw new Error("No encounter_content link found");
  }

  const response = await fetch(
    BASE_URL + AMBIENT_PATH + encounterLinks[0].href,
    { headers: HEADERS }
  );
  if (!response.ok) {
    throw new Error(`Encounter content call failed: ${response.status}`);
  }
  return response.json();
}

func loadEncounterContent(links map[string][]link) (map[string]any, error) {
	encounterLinks := links["encounter_content"]
	if len(encounterLinks) == 0 {
		return nil, fmt.Errorf("no encounter_content link found")
	}
	return getJSON(encounterLinks[0].Href)
}