@openagentid/sdk-testing

declare function createTestingConfig(overrides?: Partial<OpenAgentConfig>): OpenAgentConfig;

declare function stubArsenalClient(): ArsenalClient;

declare class StubIdentityProvider implements IdentityProvider {
    constructor(namespace?: string);
    createAgentIdentity(input: CreateAgentInput): Promise<IdentityDocument>;
    resolve(did: Did): Promise<IdentityDocument>;
    signChallenge(did: Did, challenge: Uint8Array): Promise<SignedAssertion>;
    publicKey(did: Did): Promise<string>;
}

declare class StubVerificationClient implements 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 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;
}>;

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 SignedAssertion {
    token: string;
    signature: string;
    signer: Did;
    issuedAt: number;
    expiresAt: number;
}

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-+9TXTWFWNxn9dyZLZTK5GEsUIYdGS2rUCHubsy+WGGCbrVaKRwAvEW+bOQV5Nr6dd/EmQE3jum6XKB1DvffCPA==