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

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

export const agentCardSchema = agentSchema.omit("createdAt")

export const agentId: Schema.Schema<AgentId, string> = formatString(
  "uuid",
).pipe(
  Schema.brand("AgentId"),
  Schema.annotations({ description: "Branded AgentId" }),
)

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

export const agentKey: Schema.Schema<AgentKey, string> =
  Schema.Redacted(agentKeyValue)

export type AgentKey = Redacted.Redacted<AgentKeyValue>;

export const agentName: Schema.Schema<AgentName, string> = Schema.String.pipe(
  Schema.minLength(3),
  Schema.maxLength(32),
  Schema.pattern(new RegExp("^[a-z0-9][a-z0-9_-]{1,30}[a-z0-9]$")),
  Schema.brand("AgentName"),
  Schema.annotations({
    description:
      "Lowercase wire-safe identity name (3–32 characters, alphanumeric ends)",
  }),
)

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

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

export function agentOwnershipSchema(): typeof agentOwnershipSchemaValue

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: [AuthenticatedAgent, ActiveAgent],
  errors: [InvalidParamsError],
})

export const inviteCode: Schema.Schema<InviteCode, string> =
  Schema.Redacted(inviteCodeValue)

export type InviteCode = Redacted.Redacted<InviteCodeValue>;

export const register = defineRpc({
  name: "agent/identity/register",
  params: Schema.Struct({
    name: agentName,
    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)