> ## Documentation Index
> Fetch the complete documentation index at: https://docs.colosseum.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Field reference

> Request and response fields for the Copilot API.

These are the fields for each endpoint in the [API overview](/copilot/api-reference). You don't need them to use Copilot through your agent.

Fields are written in a short schema notation, not as sample responses:

* `[optional]` means the field can be left out. `null` is a separate value from a missing field.
* `[default x]` is the value used when the field is left out.
* `int` means a whole number. Bounds on arrays count items; bounds on strings count characters.
* Dates are ISO 8601 strings. Request objects marked `[strict]` reject unknown fields.
* `v2CategoryKey` is one of the 41 category keys from `GET /categories`.

## Your own data

### arenaProfile

The signed-in profile and Arena-visible teammate profiles use these fields:

```text wrap theme={null}
displayName: string | null
username: string | null
bio: string | null
city: string | null
country: string | null
languages: Array<string>
currentPosition: string | null
lookingToBuild: string | null
lookingForCollab: boolean
isUniversityStudent: boolean | null
roles: Array<string>
rolesLookingFor: Array<string>
skills: Array<string>
interestedUseCases: Array<string>
githubHandle: string | null
linkedinHandle: string | null
twitterHandle: string | null
telegramHandle: string | null
```

A teammate without a visible Arena profile has only `displayName` and `username`. No teammate email is returned.

### meResponse

Returned by `GET /me` for the signed-in person. `submission` can contain draft and private fields.

```text wrap theme={null}
profile: arenaProfile & { cofounderMatching: { hasProfile: boolean; publicPageUrl: string [url] | null } }
currentHackathon: { name: string; slug: string; registered: boolean }
projects: Array<{
  name: string; slug: string | null; publicPageUrl: string [url] | null
  program: { type: "hackathon" | "eternal"; name: string; slug: string; current: boolean }
  status: "draft" | "submitted"; role: "owner" | "member"
  tracks: Array<string>; description: string
  submission: {
    category: string | null; otherProductCategory: string | null; country: string | null
    website: string | null; repoLink: string | null; presentationLink: string | null
    technicalDemoLink: string | null; pitchVideoLink: string | null; demoVideoLink: string | null
    demoVideoPublic: boolean; twitterHandle: string | null; telegramHandle: string | null
    liveProductLink: string | null; liveProductAccessInstructions: string | null
    additionalInfo: string | null; whatBuilding: string | null; whyNow: string | null
    technologies: string | null; repoContext: string | null; marketValidation: string | null
    traction: string | null; competition: string | null; monetization: string | null
    teamCommitment: string | null; teamLocationDetails: string | null; chainUsage: string | null
    chains: Array<string>; externalContributors: string | null
    isUniversityProject: boolean; universityName: string | null; isSolanaMobile: boolean
    acceleratorOptIn: boolean | null; legalEntity: boolean | null; legalEntityDetails: string | null
    investmentReceived: boolean | null; investmentDetails: string | null
    currentlyFundraising: boolean | null; fundraisingDetails: string | null
    liveToken: boolean | null; liveTokenDetails: string | null
    surveyAnswers: unknown | null
    eternalDetails: { targetAudience: string; teamSuitability: string; startedAndPriorities: string; raised: string; productDescription: string } | null
  }
  teammates: Array<arenaProfile | { displayName: string | null; username: string | null }>
  prize: { type: string; name: string | null; amount: number | null; placement: number | null; honorableMention: boolean } | null
  acceleratorCompany: { name: string; cohort: string } | null
  updates: Array<{ kind: "hackathon" | "eternal" | "buildLog"; number: number [int] | null; publishedAt: string [datetime]; links: Array<string> }>
}>
truncated: { projects: boolean; updates: boolean }
```

`prize` is non-null only after the results are published. The response returns at most 200 projects and 2,000 updates across them; `truncated` marks either cap. It does not include judging scores, reviews or application status.

## Projects

### searchProjectsRequest

```text wrap theme={null}
query: string [trim, max 500] [optional] [default ""]
hackathons: Array<string [min 1]> [max 10] [optional]
trackKeys: Array<string [pattern /^[a-z0-9-]+\/[a-z0-9-]+$/]> [max 10] [optional]
labelKeys: Array<string [pattern /^label:[a-z0-9-]+\/[a-z0-9-]+$/]> [max 10] [optional]
limit: number [int, min 1, max 25] [default 10]
offset: number [int, min 0] [default 0]
filters: { categoryKeys: Array<v2CategoryKey | "other-emerging" | "insufficient-information"> [min 1, max 10] [optional]; includeSecondaryCategories: boolean [optional, default false]; builtWith: builtWithFilters [optional]; winnersOnly: boolean [optional]; acceleratorOnly: boolean [optional]; acceleratorBatchKeys: Array<string [pattern /^accelerator\/[a-z0-9-]+$/]> [max 10] [optional]; prizePlacements: Array<number [int]> [optional]; prizeTypes: Array<string> [max 10] [optional]; isUniversityProject: boolean [optional]; isSolanaMobile: boolean [optional]; techStack: Array<string> [max 10] [optional]; primitives: Array<string> [max 10] [optional]; problemTags: Array<string> [max 10] [optional]; solutionTags: Array<string> [max 10] [optional]; targetUsers: Array<string> [max 10] [optional] } [strict] [optional]
diversify: boolean [optional] [default false]
includeFacets: boolean [optional] [default false]
facets: Array<"categories" | "hackathons" | "tracks" | "labels" | "clusters" | "prizes" | "problemTags" | "solutionTags" | "primitives" | "techStack"> [optional]
facetTopK: number [int, min 1, max 43 with includeFacets and "categories" in facets; otherwise max 20] [optional] [default 8]
includeDiagnostics: boolean [optional] [default false]
```

`trackKeys` and `labelKeys` cannot be combined. `tracks` lists the prize tracks a project entered, not the one it won; the winning track is `prize.trackName`. `labels` contains submission choices for events without track prizes. `ambiguous` returns neither until classification is resolved. `filters.categoryKeys` matches any listed key. `filters.includeSecondaryCategories: true` also matches a project's second category; category counts can then overlap. `filters.winnersOnly` excludes honorable mentions. `diversify` spreads results across hackathons and tracks.

### searchProjectsResponse

```text wrap theme={null}
results: Array<projectSearchResult>
filtersApplied: { hackathons: Array<string> [optional]; trackKeys: Array<string [pattern /^[a-z0-9-]+\/[a-z0-9-]+$/]> [optional]; labelKeys: Array<string [pattern /^label:[a-z0-9-]+\/[a-z0-9-]+$/]> [optional]; filters: { categoryKeys: Array<v2CategoryKey | "other-emerging" | "insufficient-information"> [min 1, max 10] [optional]; includeSecondaryCategories: boolean [optional, default false]; builtWith: builtWithFilters [optional]; winnersOnly: boolean [optional]; acceleratorOnly: boolean [optional]; acceleratorBatchKeys: Array<string [pattern /^accelerator\/[a-z0-9-]+$/]> [max 10] [optional]; prizePlacements: Array<number [int]> [optional]; prizeTypes: Array<string> [max 10] [optional]; isUniversityProject: boolean [optional]; isSolanaMobile: boolean [optional]; techStack: Array<string> [max 10] [optional]; primitives: Array<string> [max 10] [optional]; problemTags: Array<string> [max 10] [optional]; solutionTags: Array<string> [max 10] [optional]; targetUsers: Array<string> [max 10] [optional] } [strict] [optional] }
totalFound: number [int]
hasMore: boolean
categoryCountsOverlap: boolean [optional]
facets: { categories: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; clusters: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; hackathons: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; tracks: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; labels: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; prizes: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; problemTags: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; solutionTags: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; primitives: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; techStack: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional] } [optional]
diagnostics: searchDiagnostics [optional]
```

With an empty query, `totalFound` is the exact number of matching projects. With a text query, it only supports paging. `categoryCountsOverlap` is true when category counts include second categories.

### projectSearchResult

```text wrap theme={null}
builtWith: compactBuiltWith | null [optional]
categories: { version: string; primaryKey: v2CategoryKey | "other-emerging" | "insufficient-information"; secondaryKey: v2CategoryKey | null; confidence: "high" | "medium" | "low" } | null [optional]
slug: string
name: string
oneLiner: string | null
similarity: number
hackathon: { name: string; slug: string; startDate: string }
tracks: Array<{ name: string; key: string [pattern /^[a-z0-9-]+\/[a-z0-9-]+$/] }>
labels: Array<string>
trackClassification: "prize_tracks" | "submission_labels" | "ambiguous"
award: "winner" | "honorable_mention" | null
crowdedness: number [int] | null
cluster: { key: string [pattern /^v\d+-c\d+$/]; label: string } | null
links: { github: string | null; demo: string | null; presentation: string | null; technicalDemo: string | null; twitter: string | null; colosseum: string | null; repoPublic: boolean [optional] }
evidence: Array<string> [max 2]
corpusRevision: string [optional]
freshness: projectFreshness [optional]
prize: { type: string; name: string | null; placement: number [int] | null; amount: number | null; trackName: string | null } | null
metrics: { updatesCount: number [int] }
team: { count: number [int] }
tags: { problemTags: Array<string> [max 10]; solutionTags: Array<string> [max 10]; primitives: Array<string> [max 10]; techStack: Array<string> [max 10]; targetUsers: Array<string> [max 10] } | null
accelerator: { companySlug: string | null; companyName: string | null; batchKey: string [pattern /^accelerator\/[a-z0-9-]+$/]; batchName: string } | null
```

`evidence` holds up to two matching snippets. `builtWith` lists up to 10 tool names per kind; fetch project details for the full record. `award: "honorable_mention"` identifies honorable mentions. They carry `prize.type: "HONORABLE_MENTION"` with no amount, and they're recognitions, not wins. `prize.trackName` is the track a project won. Frontier had no tracks: its 25 `TRACK_PRIZE` awards named `Winner` are its top-25 awards, not track prizes.

### searchDiagnostics

Returned when `includeDiagnostics` is true.

```text wrap theme={null}
modeUsed: "vector" | "text" | "hybrid" | "filters"
fallbackUsed: boolean
fallbackReason: string [optional]
vectorCandidates: number [int]
textCandidates: number [int]
tagCandidates: number [int]
diversityDropped: number [int]
missingVectorProjects: number [int] [optional]
missingVectorMatches: number [int] [optional]
totalFoundIsEstimate: boolean
queryExpanded: string
effectiveFilters: Record<string, unknown>
```

`modeUsed` says how results were ranked. `"vector"` scores by similarity (higher is closer), `"hybrid"` combines similarity, text and tags, `"text"` uses a fixed score, and `"filters"` (an empty query) scores 0 and lists newest first. Compare scores only within the same mode.

### getProjectBySlugParams

```text wrap theme={null}
slug: string
```

### projectDetails

```text wrap theme={null}
builtWith: repositoryTags | null [optional]
categories: { version: string; primaryKey: v2CategoryKey | "other-emerging" | "insufficient-information"; secondaryKey: v2CategoryKey | null; confidence: "high" | "medium" | "low" } | null [optional]
evidenceSummaries: projectEvidence [optional]
corpusRevision: string [optional]
freshness: projectFreshness [optional]
slug: string
name: string
description: string | null
oneLiner: string | null
hackathon: { name: string; slug: string; startDate: string }
tracks: Array<{ name: string; key: string [pattern /^[a-z0-9-]+\/[a-z0-9-]+$/] }>
labels: Array<string>
trackClassification: "prize_tracks" | "submission_labels" | "ambiguous"
award: "winner" | "honorable_mention" | null
cluster: { key: string [pattern /^v\d+-c\d+$/]; label: string } | null
links: { github: string | null; demo: string | null; presentation: string | null; technicalDemo: string | null; twitter: string | null; colosseum: string | null; repoPublic: boolean [optional] }
team: { count: number [int]; members: Array<{ displayName: string | null; username: string | null; githubHandle: string | null; twitterHandle: string | null }> }
isWinner: boolean
accelerator: { companySlug: string | null; companyName: string | null; batchKey: string [pattern /^accelerator\/[a-z0-9-]+$/]; batchName: string } | null
createdAt: string
tags: { problemTags: Array<string> [max 10]; solutionTags: Array<string> [max 10]; primitives: Array<string> [max 10]; techStack: Array<string> [max 10]; targetUsers: Array<string> [max 10] } | null
metrics: { updatesCount: number [int] } | null
prize: { type: string; name: string | null; placement: number [int] | null; amount: number | null; trackName: string | null } | null
```

`isWinner` is false for honorable mentions. `categories.confidence` says how clearly the project fits its main category, not how good it is. `categories: null` means the project hasn't been categorized yet.

### projectEvidence

Summaries of what the team submitted: its code, pitch and demo. A missing summary means Copilot has none, not that the team submitted nothing.

```text wrap theme={null}
repoSummary: projectEvidenceSummary | null
pitchSummary: projectEvidenceSummary | null
demoSummary: projectEvidenceSummary | null
```

### projectEvidenceSummary

```text wrap theme={null}
text: string [max 12000]
truncated: boolean
sourceUrl: string [url] | null
sourceRevision: string
sourceCapturedAt: string [datetime] | null
generatedAt: string [datetime] | null
indexedAt: string [datetime]
capturedAt: string [datetime] | null
sourceInferred: boolean
evidenceId: string | null
extractorVersion: string
```

`text` keeps Markdown up to 12,000 characters; `truncated` is true only when that limit cuts it off. `sourceUrl` links the public repository, presentation or demo, or is null when no valid link is known. The linked page may have changed since capture.

`sourceCapturedAt` is when the source was captured; `capturedAt` is the same value under an older name. `generatedAt` is when the summary was written, and `indexedAt` is when Copilot last took it in. None of these dates show whether the project is still active. `sourceInferred` is true when the source was matched by type rather than declared by the team.

### projectFreshness

```text wrap theme={null}
projectsSyncedAt: string [datetime] | null
embeddingsVersion: string | null
archiveIngestedAt: string [datetime] | null
```

### Tools found in a project's code

`builtWith` lists the tools found in a project's public code when it was captured. It doesn't show that the project still runs, or how the tools are used. `builtWith: null` means no record is available. An empty list for one kind means none was found, not that none was used.

Project details return up to 100 tools per kind. Each has a display `name`, a `confidence` from 0 to 1, and an `evidence` quote of up to 120 characters. A `version` appears only when the source states one. Projects whose code isn't public return names only, without `confidence` or `evidence`.

#### repositoryTags

```text wrap theme={null}
schemaVersion: 1
languages: Array<repositoryTag> [max 100]
frameworks: Array<repositoryTag> [max 100]
chains: Array<repositoryChainTag> [max 100]
protocols: Array<repositoryTag> [max 100]
services: Array<repositoryTag> [max 100]
tooling: Array<repositoryTag> [max 100]
standards: Array<repositoryTag> [max 100]
```

#### repositoryTag

```text wrap theme={null}
name: string [trim, min 1, max 100]
version: string [trim, min 1, max 100] [optional]
confidence: number [min 0, max 1] [optional]
evidence: string [max 120] [optional]
```

#### repositoryChainTag

Includes the `repositoryTag` fields and:

```text wrap theme={null}
network: "mainnet" | "devnet" | "testnet" | "localnet" | "unknown" [optional]
```

#### compactBuiltWith

The shorter form used in search results.

```text wrap theme={null}
languages: Array<string [trim, min 1, max 100]> [max 10]
frameworks: Array<string [trim, min 1, max 100]> [max 10]
chains: Array<string [trim, min 1, max 100]> [max 10]
protocols: Array<string [trim, min 1, max 100]> [max 10]
services: Array<string [trim, min 1, max 100]> [max 10]
tooling: Array<string [trim, min 1, max 100]> [max 10]
standards: Array<string [trim, min 1, max 100]> [max 10]
```

#### builtWithFilters

```text wrap theme={null}
languages: Array<string [trim, min 1, max 100]> [max 20] [optional]
frameworks: Array<string [trim, min 1, max 100]> [max 20] [optional]
chains: Array<string [trim, min 1, max 100]> [max 20] [optional]
protocols: Array<string [trim, min 1, max 100]> [max 20] [optional]
services: Array<string [trim, min 1, max 100]> [max 20] [optional]
tooling: Array<string [trim, min 1, max 100]> [max 20] [optional]
standards: Array<string [trim, min 1, max 100]> [max 20] [optional]
```

Names match exactly, ignoring case and surrounding spaces, with no aliases. Kinds combine with AND; names within one kind combine with OR. For example, this finds Cypherpunk projects tagged with Solana and either Kamino Lend or Jupiter:

```json theme={null}
{
  "query": "",
  "hackathons": ["cypherpunk"],
  "filters": {
    "builtWith": {
      "chains": ["Solana"],
      "protocols": ["Kamino Lend", "Jupiter"]
    }
  },
  "limit": 10
}
```

These filters are separate from the older `techStack` tags.

### filtersResponse

```text wrap theme={null}
tracks: Array<{ key: string [pattern /^[a-z0-9-]+\/[a-z0-9-]+$/]; name: string; hackathonSlug: string; projectCount: number }>
labels: Array<{ key: string [pattern /^label:[a-z0-9-]+\/[a-z0-9-]+$/]; name: string; hackathonSlug: string; projectCount: number }>
hackathons: Array<{ slug: string; name: string; startDate: string; projectCount: number; winnerCount: number }>
acceleratorBatches: Array<{ key: string [pattern /^accelerator\/[a-z0-9-]+$/]; name: string; companyCount: number [int] }>
prizeTypes: Array<string>
prizePlacements: Array<number [int]>
problemTags: Array<{ tag: string; count: number [int] }>
solutionTags: Array<{ tag: string; count: number [int] }>
primitives: Array<{ tag: string; count: number [int] }>
techStack: Array<{ tag: string; count: number [int] }>
targetUsers: Array<{ tag: string; count: number [int] }>
archiveSources: Array<{ key: string; label: string; documentCount: number [int] [optional] }>
clusters: Array<{ key: string [pattern /^v\d+-c\d+$/]; label: string; projectCount: number [int] }>
```

## Analysis

### analyzeRequest

```text wrap theme={null}
cohort: { hackathons: Array<string [min 1]> [optional]; trackKeys: Array<string [pattern /^[a-z0-9-]+\/[a-z0-9-]+$/]> [optional]; winnersOnly: boolean [optional]; acceleratorOnly: boolean [optional]; acceleratorBatchKeys: Array<string [pattern /^accelerator\/[a-z0-9-]+$/]> [optional]; prizePlacements: Array<number [int]> [optional]; clusterKeys: Array<string [pattern /^v\d+-c\d+$/]> [optional]; categoryKeys: Array<v2CategoryKey | "other-emerging" | "insufficient-information"> [min 1, max 10] [optional]; includeSecondaryCategories: boolean [optional, default false] } [strict]
dimensions: Array<"categories" | "clusters" | "tracks" | "problemTags" | "solutionTags" | "primitives" | "techStack" | "targetUsers">
topK: number [int, min 1, max 43 with "categories" in dimensions; otherwise max 20] [default 10]
samplePerBucket: number [int, min 0, max 5] [default 2]
```

Category buckets count main categories unless `cohort.includeSecondaryCategories` is true. For every category bucket at once, use `dimensions: ["categories"]` with `topK: 43`.

### analyzeResponse

```text wrap theme={null}
categoryCountsOverlap: boolean [optional]
totals: { projects: number [int]; winners: number [int] }
buckets: Record<string, Array<{ key: string; label: string; count: number [int]; share: number; sampleProjectSlugs: Array<string> }>>
```

`totals.winners` excludes honorable mentions.

### cohortDefinition

Used by `POST /compare`.

```text wrap theme={null}
hackathons: Array<string [min 1]> [optional]
trackKeys: Array<string [pattern /^[a-z0-9-]+\/[a-z0-9-]+$/]> [optional]
winnersOnly: boolean [optional]
acceleratorOnly: boolean [optional]
acceleratorBatchKeys: Array<string [pattern /^accelerator\/[a-z0-9-]+$/]> [optional]
prizePlacements: Array<number [int]> [optional]
clusterKeys: Array<string [pattern /^v\d+-c\d+$/]> [optional]
```

### compareRequest

```text wrap theme={null}
cohortA: cohortDefinition
cohortB: cohortDefinition
dimensions: Array<"clusters" | "tracks" | "problemTags" | "solutionTags" | "primitives" | "techStack" | "targetUsers">
topK: number [int, min 1, max 20] [default 10]
```

### compareResponse

```text wrap theme={null}
totalsA: { projects: number [int]; winners: number [int] }
totalsB: { projects: number [int]; winners: number [int] }
results: Record<string, Array<{ key: string; label: string; countA: number [int]; shareA: number; countB: number [int]; shareB: number; lift: number; delta: number; examplesA: Array<string>; examplesB: Array<string> }>>
```

`totalsA.winners` and `totalsB.winners` exclude honorable mentions.

## Technologies

### Technology requests

```text wrap theme={null}
technology: { category: "languages" | "frameworks" | "chains" | "protocols" | "services" | "tooling" | "standards"; name: string [trim, min 1, max 100] }
cohort: {
  hackathonSlugs: Array<string [pattern /^[a-z0-9-]+$/]> [min 1, max 20] [optional]
  winnersOnly: boolean [default false]
  includeHonorableMentions: boolean [default false, requires winnersOnly]
  categoryKeys: Array<v2CategoryKey | "other-emerging" | "insufficient-information"> [min 1, max 10] [optional]
  includeSecondaryCategories: boolean [optional]
} [strict] [optional]
topK: number [int, min 1, max 50] [default 10, co-usage and top only]
technologyCategory: same values as technology.category [optional, top only]
```

Counts and trends take `technology` and `cohort`. Co-usage adds `topK`. Top takes `cohort`, `technologyCategory` and `topK`.

### Technology counts and trends

```text wrap theme={null}
technology: { category: string; name: string }
totals: { projects: number [int]; projectsWithRepositoryTags: number [int]; count: number [int]; share: number [0 to 1] } [counts only]
hackathons: Array<{ hackathon: { slug: string; name: string; startDate: string | null }; projects: number [int]; projectsWithRepositoryTags: number [int]; count: number [int]; share: number [0 to 1] }>
```

`projects` is the number of projects in the cohort, `projectsWithRepositoryTags` how many have recorded tools, and `count` how many are tagged with the technology. `share` is `count / projects`. Hackathons are in date order. Names come back in lowercase.

### Technologies used together

```text wrap theme={null}
technology: { category: string; name: string }
totals: { projects: number [int]; projectsWithRepositoryTags: number [int]; count: number [int]; share: number [0 to 1] }
results: Array<{ technology: { category: string; name: string }; count: number [int]; share: number [0 to 1]; cohortCount: number [int]; lift: number }>
```

In each result, `count` is the number of projects tagged with both technologies, and `share` is that count divided by the number tagged with the requested one. `cohortCount` is how many projects in the cohort are tagged with the other technology. `lift` is `share / (cohortCount / projects)`: above 1 means the two appear together more often than the other technology appears overall. Results are ordered by `count`.

### Top technologies

```text wrap theme={null}
totals: { projects: number [int]; projectsWithRepositoryTags: number [int] }
results: Array<{ technology: { category: string; name: string }; count: number [int]; share: number [0 to 1] }>
```

Results are ordered by `count`. Several hackathons in one cohort are combined; request each separately to rank them separately.

## Research library

### searchArchivesRequest

```text wrap theme={null}
query: string [trim, max 500, min 1]
sources: Array<string> [max 20] [optional]
limit: number [int, min 1, max 10] [default 5]
offset: number [int, min 0, max 50] [default 0]
maxChunksPerDoc: number [int, min 1, max 4] [default 2]
maxDocsPerSource: number [int, min 0, max 10] [optional] [default 3]
intent: "ideation" | "docs" [optional] [default "docs"]
minSimilarity: number [min 0, max 1] [optional] [default 0.2]
```

### searchArchivesResponse

```text wrap theme={null}
results: Array<archiveSearchResult>
filtersApplied: { sources: Array<string> [optional] }
searchTier: "vector" | "chunk_text" | "doc_text"
totalFound: number [int]
totalMatched: number [int]
hasMore: boolean
```

### archiveSearchResult

```text wrap theme={null}
documentId: string [uuid]
title: string
author: string | null
source: string
url: string | null
publishedAt: string | null
similarity: number
snippet: string [max 240 characters]
chunkIndex: number
```

### getArchiveDocumentParams

```text wrap theme={null}
documentId: string [uuid]
```

### archiveDocumentPageQuery

```text wrap theme={null}
offset: number [int, min 0] [coerced] [optional]
maxChars: number [int, min 200, max 20000] [coerced] [optional]
```

### archiveDocumentPage

```text wrap theme={null}
documentId: string [uuid]
title: string
author: string | null
source: string
url: string | null
publishedAt: string | null
content: string
restricted: boolean
isExcerpt: boolean
excerptNote: string [optional, for excerpts]
offset: number [int]
maxChars: number [int]
totalChars: number [int]
nextOffset: number [int] | null
hasMore: boolean
```

For excerpt-only sources, `isExcerpt` and `restricted` are true, and `totalChars`, `nextOffset` and `hasMore` describe only the excerpt.

## Tools and FAQs

### eventDates

V2 resources, FAQ lists and FAQ details include `eventDates`. Resources carry the dates of the requested hackathon. FAQ responses carry the dates of the most recently started hackathon, and `null` when the response has no hackathon FAQ (for example `program=accelerator`). `winnerAnnouncementDate` is `null` until Colosseum records it. Check the event's page before giving timing advice.

```text wrap theme={null}
hackathonSlug: string
startDate: string [datetime]
submissionDeadline: string [datetime]
winnerAnnouncementDate: string [datetime] | null
```

### resourcesResponse

Returned by `GET /resources`.

```text wrap theme={null}
eventDates: eventDates | null
hackathon: { name: string; slug: string; pageUrl: string [optional] }
tracks: Array<{ id: string; name: string; pageUrl: string [optional]; sponsorCards: Array<{ name: string; slug: string; trackId: string; fallback: boolean; comingSoon: boolean }> [optional]; sponsorCardsNote: string [optional] }>
source: { url: string; fetchedAt: string [datetime]; stale: boolean }
sponsors: Array<{ name: string; slug: string; trackId: string [optional]; tags: Array<string>; hasSkill: boolean; content: string; links: Array<resourceLink> }>
topics: Array<{ id: string; trackId: string [optional]; title: string; summary: string [optional]; groups: Array<{ id: string; title: string; links: Array<resourceLink> }> }>
topicGroups: Array<{ id: string; trackId: string [optional]; title: string; topicIds: Array<string> }>
rpcProviders: Array<{ name: string; trackId: string [optional]; description: string; offer: string [optional]; links: Array<resourceLink> }>
query: { track: string [optional]; q: string [optional]; topic: string [optional]; kind: string; matched: number [int] }
resourceLink: { label: string; url: string; description: string [optional, topic links only] }
```

`query.matched` counts the sponsors, topic links and RPC providers returned. `topicGroups` lists only returned topics. A hackathon with a single track returns `tracks: []`.

### faqsResponse

Returned by `GET /faqs`. `GET /faqs/:program/:id` returns `{ eventDates, source, faq }`.

```text wrap theme={null}
eventDates: eventDates | null
source: { kind: string; revision: string [sha256 digest] }
programs: Array<{ program: string; count: number [int] }>
faqs: Array<faq>
query: { program: string [optional]; q: string [optional]; matched: number [int] }
faq: { program: "hackathon" | "eternal" | "accelerator" | "stamp"; id: string; question: string; answer: string; answerFormat: "markdown"; sourceUrl: string; contentRevision: string [sha256 digest]; links: Array<{ label: string; url: string }> }
```

## Account and feedback

### statusResponse

```text wrap theme={null}
authenticated: boolean
expiresAt: string | null
scope: string | null
sessionSharingEnabled: boolean [optional; true only if the user opted in to sharing]
```

`scope` is a space-separated list of granted scopes. `expiresAt` and `scope` can be null when unknown.

### sourceSuggestionRequest

```text wrap theme={null}
url: string [url]
name: string [max 200, optional]
reason: string [max 500, optional]
```

### feedbackRequest

```text wrap theme={null}
category: "error" | "quality" | "suggestion" | "other"
message: string [trim, min 1, max 5000]
context: Record<string, unknown> [optional]
severity: "low" | "medium" | "high" | "critical" [default "medium"]
```