export type Agent = Schema.Schema.Type<typeof AgentSchema>;

export type AgentCard = Schema.Schema.Type<typeof AgentCardSchema>;

export const AgentCardSchema = AgentSchema.omit("createdAt")

export type AgentId = string & Brand.Brand<"AgentId">;

export type AgentId = string & Brand.Brand<"AgentId">

export type AgentKey = Redacted.Redacted<AgentKeyValue>;

export type AgentKey = Redacted.Redacted<AgentKeyValue>

export class AgentNotFoundError extends Schema.TaggedError<AgentNotFoundError>()(
  "AgentNotFound",
  errorPayloadFields,
) {
  static readonly message = "Agent not found";
}

export function agentOwnershipSchema(): typeof AgentOwnershipSchema

export const AgentsList = defineRpc({
  name: "agent/identity/agents/list",
  params: Schema.Struct({
    limit: ListLimitSchema,
    cursor: Schema.optional(listCursorSchema()),
  }),
  result: Schema.Struct({
    agents: Schema.Array(AgentCardSchema),
    nextCursor: Schema.optional(listCursorSchema()),
  }),
  requires: [AgentPrincipal, ActiveAgent],
  errors: [InvalidParamsError],
})

export type InviteCode = Redacted.Redacted<InviteCodeValue>;

export type InviteCode = Redacted.Redacted<InviteCodeValue>

export const Register = defineRpc({
  name: "agent/identity/register",
  params: Schema.Struct({
    name: Schema.String.pipe(
      Schema.pattern(new RegExp("^[a-z0-9][a-z0-9_-]{1,30}[a-z0-9]$")),
    ),
    description: Schema.optional(Schema.String.pipe(Schema.maxLength(500))),
    inviteCode: Schema.optional(InviteCode),
  }),
  result: Schema.Struct({
    agentId: AgentId,
    apiKey: AgentKey,
  }),
  requires: [],
  errors: [ConflictError],
})

export const validateAgent = closedStructGuard(AgentSchema)

export const validateAgentCard = closedStructGuard(AgentCardSchema)