@openagentid/skills-policy API

export declare class AuditChain {
  length(): number;
  isEmpty(): boolean;
  head(): string;
  get(sequence: number): Receipt | undefined;
  all(): readonly Receipt[];
  verify(): boolean;
  append(skill: string, agent: string, session: string, invokedAt: Date, level: AuditLevel, args: unknown): Receipt;
}

export interface Receipt {
    sequence: number;
    skill: string;
    agent: string;
    session: string;
    invokedAt: string;
    auditLevel: AuditLevel;
    argumentsHash: string;
    arguments?: unknown;
    previousHash: string;
    receiptHash: string;
}

export declare const HASH_LEN: 32;

export declare class Did {
  parse(input: string): Did;
  toString(): string;
  equals(other: Did): boolean;
  asString(): string;
}

export declare class InvocationContext {
  agentDid: Did;
  sessionId: string;
  arguments: unknown;
  invokedAt: Date;
  consentGranted: boolean;
  constructor(init: InvocationContextInit): InvocationContext;
  withConsent(): InvocationContext;
  withInvokedAt(invokedAt: Date): InvocationContext;
}

export declare class SkillsPolicy {
  fromYaml(yaml: string): SkillsPolicy;
  fromFile(path: string): Promise<SkillsPolicy>;
  agent(): Did;
  hasRule(skill: string): boolean;
  auditChain(): AuditChain;
  resetRateLimit(skill: string): void;
  canInvoke(skill: string, ctx: InvocationContext): void;
  recordInvocation(skill: string, ctx: InvocationContext): Receipt;
}

export declare class ArgumentConstraintError {
  name: "ArgumentConstraintError";
  skill: string;
  details: string;
  constructor(skill: string, details: string): ArgumentConstraintError;
}

export declare class ConsentRequiredError {
  name: "ConsentRequiredError";
  skill: string;
  constructor(skill: string): ConsentRequiredError;
}

export declare class InvalidPolicyError {
  name: "InvalidPolicyError";
  constructor(message: string): InvalidPolicyError;
}

export declare class InvalidSkillsMarkdownError {
  name: "InvalidSkillsMarkdownError";
  constructor(message: string): InvalidSkillsMarkdownError;
}

export declare class NotAllowedError {
  name: "NotAllowedError";
  skill: string;
  reason: string;
  constructor(skill: string, reason: string): NotAllowedError;
}

export declare class OutsideTimeWindowError {
  name: "OutsideTimeWindowError";
  skill: string;
  constructor(skill: string): OutsideTimeWindowError;
}

export declare class RateLimitExceededError {
  name: "RateLimitExceededError";
  skill: string;
  used: number;
  max: number;
  windowSecs: number;
  constructor(skill: string, used: number, max: number, windowSecs: number): RateLimitExceededError;
}

export declare class SkillsPolicyError {
  name: string;
  constructor(message: string): SkillsPolicyError;
}

export declare class RateLimiter {
  checkAndRecord(skill: string, limit: RateLimit, nowSecs: number): RateLimitDecision;
  reset(skill: string): void;
  snapshot(): Array<[string, number]>;
}

export type RateLimitDecision = {
    kind: "allowed";
} | {
    kind: "denied";
    used: number;
};

export type AuditLevel = z.infer<typeof AuditLevelSchema>;

export declare const CURRENT_VERSION: 1;

export type DefaultRule = z.infer<typeof DefaultRuleSchema>;

export declare const MAX_SKILL_RULES: 256;

export type RateLimit = z.infer<typeof RateLimitSchema>;

export type SkillRule = z.infer<typeof SkillRuleSchema>;

export type SkillsPolicyDoc = z.infer<typeof SkillsPolicyDocSchema>;

export type TimeWindow = z.infer<typeof TimeWindowSchema>;

export interface SkillEntry {
    readonly name: string;
    readonly description: string;
}

export declare class SkillsManifest {
  skills: readonly SkillEntry[];
  fromMarkdown(input: string): SkillsManifest;
  fromFile(path: string): Promise<SkillsManifest>;
  length(): number;
  isEmpty(): boolean;
  get(name: string): SkillEntry | undefined;
  names(): string[];
}