@openagentid/sdk/agent

declare const OpenAgent: {
    readonly configure: (config?: OpenAgentConfig) => OpenAgentRuntime;
    readonly runtime: () => OpenAgentRuntime;
    readonly createAgent: (input: CreateAgentInput) => Promise<OpenAgentInstance>;
    readonly loadAgent: (did: Did, skills?: readonly SkillId[]) => Promise<OpenAgentInstance>;
    readonly authenticate: (req: Request, options?: VerifyRequestOptions) => Promise<AuthContext>;
};

interface OpenAgentInstance {
    readonly did: Did;
    readonly document: IdentityDocument;
    skillsPolicy(): SkillsPolicy;
    withSkillsPolicy(policy: SkillsPolicy): OpenAgentInstance;
    credentialsFor(provider: string, scopes?: readonly string[]): Promise<CredentialHandle>;
    identity(): IdentityProvider;
}

declare class OpenAgentRuntime {
    constructor(config?: OpenAgentConfig);
    config(): Readonly<ResolvedOpenAgentConfig>;
    identity(): IdentityProvider;
    arsenal(): ArsenalClient;
    verification(): VerificationClient;
    createAgent(input: CreateAgentInput): Promise<OpenAgentInstance>;
    loadAgent(did: Did, skills?: readonly SkillId[]): Promise<OpenAgentInstance>;
    authenticate(req: Request, options?: VerifyRequestOptions): Promise<AuthContext>;
}

interface ArsenalClient {
    requestCredential(params: {
        agentDid: Did;
        provider: string;
        scopes?: readonly string[];
    }): Promise<IssuedCredential>;
    release?(credentialProxyUrl: string): Promise<void>;
}

interface AuthContext {
    readonly did: Did;
    readonly root: Did;
    readonly lineage: readonly Did[];
    readonly lineageAuthority?: LineageAuthorityContext;
    readonly scopes: readonly string[];
    readonly expiresAt: number;
    readonly presentedToken?: string;
    readonly claims?: Readonly<Record<string, unknown>>;
}

type AvatarExpression = typeof CHARACTER_EXPRESSIONS[number];

declare const CHARACTER_EXPRESSIONS: readonly [
    "neutral",
    "attentive",
    "surprised",
    "excited",
    "happy",
    "laughing",
    "angry",
    "sad",
    "scared",
    "suspicious",
    "confused",
    "curious",
    "proud",
    "shy",
    "unimpressed",
    "sleepy",
    "thoughtful",
    "concerned"
];

type CharacterAccessory = 'glasses' | 'headphones';

interface CharacterAppearance {
    readonly skin: CharacterSkin;
    readonly skinVersion?: 1;
    readonly eyeStyle?: CharacterEyeStyle;
    readonly finish?: CharacterFinish;
    readonly eyePlacement?: CharacterEyePlacement;
    readonly shape?: CharacterShape;
    readonly accessories?: readonly CharacterAccessory[];
}

type CharacterEyePlacement = 'face' | 'raised';

type CharacterEyeStyle = 'live-v1';

type CharacterFinish = 'plush' | 'flat';

type CharacterShape = 'standard' | 'slender' | 'wide' | 'circle' | 'pebble' | 'squircle' | 'capsule' | 'triangle' | 'hexagon' | 'cloud' | 'droplet' | 'kite' | 'fan' | 'bud' | 'leaf' | 'drop' | 'wave' | 'comet' | 'satellite' | 'mitt' | 'hood' | 'crystal' | 'obelisk' | 'spring' | 'bellows' | 'vase' | 'teapot' | 'flame' | 'curl' | 'radio' | 'beacon' | 'tower' | 'arch' | 'pom' | 'bear' | 'pumpkin' | 'ghost' | 'bat' | 'witch-hat' | 'candy-corn' | 'turkey' | 'acorn' | 'squash' | 'pie' | 'corn' | 'light' | 'tree' | 'snowman' | 'ornament' | 'gift';

type CharacterSkin = 'autos' | 'spacex' | 'fold' | 'sprig' | 'ripple' | 'halo' | 'purl' | 'prism' | 'coil' | 'kiln' | 'wisp' | 'relay' | 'cairn' | 'tuft' | 'halloween' | 'thanksgiving' | 'christmas';

type CreateAgentInput = z.infer<typeof createAgentInputSchema>;

declare const createAgentInputSchema: z.ZodObject<{
    parent: z.ZodEffects<z.ZodString, string, string>;
    name: z.ZodString;
    scopes: z.ZodArray<z.ZodString, "many">;
    namespace: z.ZodOptional<z.ZodString>;
    skills: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strict", z.ZodTypeAny, {
    parent: string;
    name: string;
    scopes: string[];
    namespace?: string | undefined;
    skills?: string[] | undefined;
    metadata?: Record<string, unknown> | undefined;
}, {
    parent: string;
    name: string;
    scopes: string[];
    namespace?: string | undefined;
    skills?: string[] | undefined;
    metadata?: Record<string, unknown> | undefined;
}>;

interface CredentialHandle {
    readonly provider: string;
    readonly agentDid: Did;
    readonly expiresAt: number;
    fetch: typeof fetch;
    refresh(): Promise<CredentialHandle>;
    release(): Promise<void>;
}

type Did = string;

interface IdentityDocument {
    did: Did;
    parent: Did;
    publicKeyMultibase: string;
    kind: string;
    scopes: readonly string[];
    createdAt: string;
    avatarOverride?: string | null;
    avatarSkin?: CharacterAppearance | null;
    avatarExpression?: AvatarExpression;
    metadata?: Record<string, unknown>;
}

interface IdentityProvider {
    createAgentIdentity(input: CreateAgentInput): Promise<IdentityDocument>;
    resolve(did: Did): Promise<IdentityDocument>;
    signChallenge(did: Did, challenge: Uint8Array): Promise<SignedAssertion>;
    publicKey(did: Did): Promise<string>;
}

interface IssuedCredential {
    provider: string;
    proxyUrl: string;
    expiresAt: number;
    remainingCalls?: number;
    metadata?: Record<string, unknown>;
}

interface LineageAuthorityContext {
    readonly subject: Did;
    readonly source: string;
    readonly root: Did;
    readonly path: readonly Did[];
    readonly finalizedBlock: number;
    readonly pathKind: string;
    readonly scopes: readonly string[];
    readonly generation: number;
    readonly rootKind?: string;
    readonly orgRootCommitment?: string;
    readonly expiresAt?: string;
}

interface Logger {
    debug(msg: string, fields?: Record<string, unknown>): void;
    info(msg: string, fields?: Record<string, unknown>): void;
    warn(msg: string, fields?: Record<string, unknown>): void;
    error(msg: string, fields?: Record<string, unknown>): void;
}

interface OpenAgentClients {
    readonly identity?: unknown;
    readonly credentials?: unknown;
    readonly verification?: unknown;
}

interface OpenAgentConfig {
    namespace?: string;
    endpoints?: {
        oasResolver?: string;
        arsenalBroker?: string;
        aegisVerifier?: string;
    };
    fetch?: typeof fetch;
    logger?: Logger;
    requestTimeoutMs?: number;
    clients?: OpenAgentClients;
}

interface ResolvedOpenAgentConfig {
    namespace: string;
    endpoints: {
        oasResolver?: string;
        arsenalBroker?: string;
        aegisVerifier?: string;
    };
    fetch: typeof fetch;
    logger: Logger;
    requestTimeoutMs: number;
    clients: OpenAgentClients;
}

interface SignedAssertion {
    token: string;
    signature: string;
    signer: Did;
    issuedAt: number;
    expiresAt: number;
}

type SkillId = string;

interface SkillsPolicy {
    canInvoke(skill: SkillId): boolean;
    assertCanInvoke(skill: SkillId): void;
    listAllowed(): readonly SkillId[];
    grant(skill: SkillId): SkillsPolicy;
    revoke(skill: SkillId): SkillsPolicy;
}

interface VerificationClient {
    verifyRequest(req: Request, options?: VerifyRequestOptions): Promise<AuthContext>;
    issueChallenge(): Promise<{
        challenge: Uint8Array;
        challengeId: string;
    }>;
    verifyChallengeResponse(params: {
        challengeId: string;
        agentDid: Did;
        signatureBase64: string;
    }): Promise<AuthContext>;
}

interface VerifyRequestOptions {
    requiredScopes?: readonly string[];
    requiredAncestor?: Did;
    requirePrivilegedAuthority?: boolean;
    requiredAuthorityPath?: string;
    clockSkewSeconds?: number;
}

sha512-9YlDb02di8sGffhuMOwNAQa/M3oBrhaqPc7t+qBltdoQRCqlxDmYB/nTRSB4eZgwE4lvM4TKzI72nJtJSVm/ww==