86 lines
3.6 KiB
TypeScript
86 lines
3.6 KiB
TypeScript
// The enablement platform over the platform's own APIs, server-side. Eligibility reads the
|
|
// rollout flags (agent_document_tools, agent_knowledge_tools) from the flag snapshot and probes
|
|
// the AI tools registry for the document tool family — discovery is the cheap plan/binding/flag
|
|
// filter, and "a working OCR endpoint does not by itself make OCR a discoverable tool". Nothing is
|
|
// provisioned for the app: the platform's knowledge service owns the index (ADR-061). The quota
|
|
// pre-check has no platform API yet (the metering slice owns it); the indexing calls themselves
|
|
// carry the typed quota_exhausted refusal at run time.
|
|
|
|
import { createRegistryClient, ToolIndexingError } from "@conusai-sdk/ai"
|
|
import type { EnablementReason } from "../contract/index.js"
|
|
import type { DocumentAiPlatform } from "../core/ports.js"
|
|
|
|
export const AGENT_DOCUMENT_TOOLS_FLAG = "agent_document_tools"
|
|
export const AGENT_KNOWLEDGE_TOOLS_FLAG = "agent_knowledge_tools"
|
|
|
|
const FLAG_KEYS = [AGENT_DOCUMENT_TOOLS_FLAG, AGENT_KNOWLEDGE_TOOLS_FLAG] as const
|
|
|
|
export interface SdkDocumentAiPlatformOptions {
|
|
/** The deployment contract's API URL and token. */
|
|
apiUrl: string
|
|
token: string
|
|
fetch?: typeof fetch
|
|
}
|
|
|
|
export function sdkDocumentAiPlatform(options: SdkDocumentAiPlatformOptions): DocumentAiPlatform {
|
|
const http = options.fetch ?? fetch
|
|
|
|
const rolloutFlagsOff = async (): Promise<string | null> => {
|
|
try {
|
|
const response = await http(new URL(`${options.apiUrl.replace(/\/+$/, "")}/flags/snapshot`), {
|
|
headers: { authorization: `Bearer ${options.token}`, accept: "application/json" },
|
|
signal: AbortSignal.timeout(5_000),
|
|
})
|
|
if (!response.ok) return null // the flags service is not the eligibility authority
|
|
const body = (await response.json()) as { flags?: Array<{ key?: string; enabled?: boolean }> }
|
|
for (const flag of body.flags ?? []) {
|
|
if (
|
|
typeof flag.key === "string" &&
|
|
(FLAG_KEYS as readonly string[]).includes(flag.key) &&
|
|
flag.enabled === false
|
|
) {
|
|
return flag.key
|
|
}
|
|
}
|
|
return null
|
|
} catch {
|
|
return null
|
|
}
|
|
}
|
|
|
|
return {
|
|
async checkEligibility(): Promise<{ ok: true } | { ok: false; reason: EnablementReason; detail?: string }> {
|
|
// The rollout flags first: a kill switch or a disabled feature refuses before any probe.
|
|
const off = await rolloutFlagsOff()
|
|
if (off !== null) return { ok: false, reason: "feature_disabled", detail: `the ${off} flag is off` }
|
|
// The plan probe: can this deployment discover the document tool family at all?
|
|
try {
|
|
const registry = createRegistryClient({
|
|
env: { CONUSAI_API_URL: options.apiUrl, CONUSAI_API_TOKEN: options.token },
|
|
fetch: http,
|
|
})
|
|
const found = await registry.tools.search("read and index documents")
|
|
if (found.length === 0) {
|
|
return { ok: false, reason: "plan_required", detail: "the ai_tools plan capability lists no document tools" }
|
|
}
|
|
return { ok: true }
|
|
} catch (error) {
|
|
if (error instanceof ToolIndexingError) {
|
|
return { ok: false, reason: "feature_disabled", detail: "the tool registry is still indexing" }
|
|
}
|
|
return {
|
|
ok: false,
|
|
reason: "plan_required",
|
|
detail: "the AI tools registry did not answer the eligibility probe",
|
|
}
|
|
}
|
|
},
|
|
|
|
async indexingQuota() {
|
|
// No pre-check API exists on the platform yet; the call-time quota refusal is the hard
|
|
// gate. Until the limit endpoint lands, the admission check answers "within quota".
|
|
return Number.MAX_SAFE_INTEGER
|
|
},
|
|
}
|
|
}
|