Agent loop

from sid import DocumentCache
from sid.document_cache import SNIPPET_SIZE_DEFAULT


def render_results(cache, results, query, snippet_size=SNIPPET_SIZE_DEFAULT):
    rendered = []
    for result in results:
        document = dict(result)
        data_id = document.pop("id")
        cache.add_document(data_id, document)
        view = cache.apply_snippet(
            data_id,
            snippet_field="content",
            query=query,
            snippet_size=snippet_size,
        )
        rendered.append(view.render_xml())
        cache.update_seen(view)

    return "\n".join(rendered) if rendered else "No results found. Try a different query."

import { DocumentCache, SNIPPET_SIZE_DEFAULT } from "@sid-ai/sid-sdk";

type SearchResult = { id: string; content: string; [field: string]: unknown };

function renderResults(cache: DocumentCache, results: SearchResult[], query: string, snippetSize = SNIPPET_SIZE_DEFAULT): string {
  const rendered: string[] = [];
  for (const { id: dataId, ...document } of results) {
    cache.addDocument(dataId, document);
    const view = cache.applySnippet(dataId, {
      snippetField: "content", query, snippetSize,
    });
    rendered.push(view.renderXml());
    cache.updateSeen(view);
  }
  return rendered.join("\n") || "No results found. Try a different query.";
}

import sid "github.com/sidhq/sid-go"

func renderResults(cache *sid.DocumentCache, results []map[string]any, query string, snippetSize int) (string, error) {
	var rendered []string
	for _, result := range results {
		document := maps.Clone(result)
		dataID := document["id"].(string)
		delete(document, "id")
		if _, err := cache.AddDocument(dataID, document); err != nil {
			return "", err
		}
		view, err := cache.ApplySnippet(dataID, sid.ApplySnippetOptions{
			SnippetField: "content", Query: query, SnippetSize: snippetSize,
		})
		if err != nil {
			return "", err
		}
		xml, err := view.RenderXML()
		if err != nil {
			return "", err
		}
		rendered = append(rendered, xml)
		if err := cache.UpdateSeen(view); err != nil {
			return "", err
		}
	}
	if len(rendered) == 0 {
		return "No results found. Try a different query.", nil
	}
	return strings.Join(rendered, "\n"), nil
}

fetches = [pool.submit(fetch_results, call.name, args) for call, args in zip(calls, arguments)]

# Compose observations serially, in call order: what earlier calls show, later calls mask.
for call, args, fetch in zip(calls, arguments, fetches):
    observation = render_results(
        cache, fetch.result(), args["query"], args.get("snippet_size", SNIPPET_SIZE_DEFAULT)
    )
    ...

// Fetch search results concurrently, then render in call order.
const fetches = await Promise.all(calls.map((call, i) => fetchResults(call.name, args[i])));
for (let i = 0; i < calls.length; i++) {
  const observation = renderResults(
    cache, fetches[i], args[i].query, args[i].snippet_size ?? SNIPPET_SIZE_DEFAULT,
  );
  // Append the observation for this call.
}

// Fetch search results concurrently, then render in call order.
fetched := make([][]map[string]any, len(calls))
fetchErrors := make([]error, len(calls))
var wg sync.WaitGroup
for i, call := range calls {
	wg.Add(1)
	go func() {
		defer wg.Done()
		fetched[i], fetchErrors[i] = fetchResults(ctx, call.Name, args[i])
	}()
}
wg.Wait()

for i := range calls {
	if fetchErrors[i] != nil {
		log.Fatal(fetchErrors[i])
	}
	query, _ := args[i]["query"].(string)
	snippetSize := sid.SnippetSizeDefault
	if size, ok := args[i]["snippet_size"].(float64); ok {
		snippetSize = int(size)
	}
	observation, err := renderResults(cache, fetched[i], query, snippetSize)
	if err != nil {
		log.Fatal(err)
	}
	// Append the observation for this call.
}

from sid import parse_rendered_model_facing_id


def reported_data_ids(cache, references):
    model_ids = [parse_rendered_model_facing_id(ref)[0] for ref in references]
    return [
        cache.to_data_id(model_id)
        for model_id in dict.fromkeys(model_ids)
        if cache.contains_model_facing_id(model_id)
    ]

import { parseRenderedModelFacingId } from "@sid-ai/sid-sdk";

function reportedDataIds(cache: DocumentCache, references: string[]): string[] {
  const modelIds = references.map(ref => parseRenderedModelFacingId(ref)[0]);
  return [...new Set(modelIds)]
    .filter(id => cache.containsModelFacingId(id))
    .map(id => cache.toDataId(id));
}

import sid "github.com/sidhq/sid-go"

func reportedDataIDs(cache *sid.DocumentCache, references []string) ([]string, error) {
	var dataIDs []string
	seen := map[string]bool{}
	for _, reference := range references {
		modelID, _, err := sid.ParseRenderedModelFacingID(reference)
		if err != nil {
			return nil, err
		}
		if seen[modelID] || !cache.ContainsModelFacingID(modelID) {
			continue
		}
		seen[modelID] = true
		dataID, err := cache.ToDataID(modelID)
		if err != nil {
			return nil, err
		}
		dataIDs = append(dataIDs, dataID)
	}
	return dataIDs, nil
}