@pensar/apex 2.5.0 → 2.6.1-canary.025b1ecf

package/build/lib/chunk-ve7m90fb.js

@@ -0,0 +1,317 @@
+import {
+  runWithNativeRolloutSession2
+} from "./chunk-sgd2126b.js";
+import {
+  AgentEventBus2
+} from "./chunk-7gjdygcx.js";
+import {
+  runWithBoundedConcurrency,
+  randomSessionIdFactory2,
+  inProcessSeams2,
+  resolveItemHooks2
+} from "./chunk-c2b0hxs7.js";
+import {
+  __export
+} from "./chunk-n0ba7khr.js";
+
+// src/core/agents/offSecAgent/subagentSpawner.ts
+var exports_subagentSpawner = {};
+__export(exports_subagentSpawner, {
+  createInProcessSubagentSpawner: () => createInProcessSubagentSpawner2,
+  inProcessSubagentSpawner: () => inProcessSubagentSpawner2,
+  runSpawnedPentestWorker: () => runSpawnedPentestWorker2
+});
+async function runSpawnedPentestWorker2(spec, input) {
+  const { TargetedPentestAgent } = await import("./core/agents/specialized/pentest/agent.js");
+  const hooks = resolveItemHooks2(input.hooks, input.seams, spec, 0);
+  const agent = new TargetedPentestAgent({
+    target: spec.target,
+    grpc: spec.grpc,
+    systemScope: spec.systemScope,
+    objectives: spec.objectives,
+    context: spec.context,
+    role: spec.role,
+    findingsRegistry: input.findingsRegistry,
+    browserSession: input.browserSession,
+    model: input.model,
+    session: input.session,
+    authConfig: input.authConfig,
+    onStepFinish: input.onStepFinish,
+    onCacheMetrics: input.onCacheMetrics,
+    eventBus: input.eventBus,
+    subagentId: input.subagentId,
+    subagentName: input.subagentName,
+    environmentVariables: input.environmentVariables,
+    secretValues: input.secretValues,
+    enableThinking: input.enableThinking,
+    thinkingEffort: input.thinkingEffort,
+    openAIReasoningEffort: input.openAIReasoningEffort,
+    display: input.display,
+    ...hooks,
+    abortSignal: input.abortSignal && hooks.abortSignal ? AbortSignal.any([input.abortSignal, hooks.abortSignal]) : input.abortSignal ?? hooks.abortSignal
+  });
+  input.onAgentConstructed?.(agent);
+  return agent.consume();
+}
+var runPentestChild = async (spec, ctx) => {
+  let constructed;
+  const workerSpec = {
+    target: spec.target,
+    grpc: spec.grpc,
+    systemScope: spec.systemScope,
+    objectives: spec.objectives,
+    context: spec.context,
+    role: spec.role
+  };
+  const workerInput = {
+    model: ctx.model,
+    session: ctx.session,
+    authConfig: ctx.authConfig,
+    abortSignal: ctx.abortSignal,
+    onStepFinish: ctx.onStepFinish,
+    onCacheMetrics: ctx.onCacheMetrics,
+    eventBus: ctx.eventBus,
+    subagentId: ctx.subagentId,
+    subagentName: ctx.subagentName,
+    findingsRegistry: spec.findingsRegistry,
+    browserSession: spec.browserSession,
+    environmentVariables: ctx.environmentVariables,
+    secretValues: ctx.secretValues,
+    enableThinking: ctx.enableThinking,
+    thinkingEffort: ctx.thinkingEffort,
+    openAIReasoningEffort: ctx.openAIReasoningEffort,
+    display: ctx.display,
+    hooks: {
+      backends: ctx.backends,
+      sandbox: ctx.sandbox,
+      languageModelMiddleware: ctx.languageModelMiddleware,
+      usageRecorder: ctx.usageRecorder,
+      streamIdFactory: ctx.streamIdFactory
+    },
+    seams: inProcessSeams2(),
+    onAgentConstructed: (agent) => {
+      constructed = agent;
+    }
+  };
+  return {
+    run: () => runSpawnedPentestWorker2(workerSpec, workerInput),
+    drained: () => constructed?.drained ?? Promise.resolve()
+  };
+};
+var runCodeChild = async (spec, ctx) => {
+  const { CodeAgent } = await import("./core/agents/specialized/codeAgent/agent.js");
+  const agent = new CodeAgent({
+    codebasePath: spec.codebasePath,
+    objective: spec.objective,
+    system: spec.system,
+    responseSchema: spec.responseSchema,
+    stopWhen: spec.stopWhen,
+    excludeTools: spec.excludeTools,
+    projectThreatModel: spec.projectThreatModel,
+    attackSurfaceRegistry: spec.attackSurfaceRegistry,
+    model: ctx.model,
+    session: ctx.session,
+    authConfig: ctx.authConfig,
+    abortSignal: ctx.abortSignal,
+    eventBus: ctx.eventBus,
+    subagentId: ctx.subagentId,
+    subagentName: ctx.subagentName,
+    sandbox: ctx.sandbox,
+    backends: ctx.backends,
+    enableThinking: ctx.enableThinking,
+    thinkingEffort: ctx.thinkingEffort,
+    openAIReasoningEffort: ctx.openAIReasoningEffort,
+    display: ctx.display,
+    onStepFinish: ctx.onStepFinish,
+    onCacheMetrics: ctx.onCacheMetrics,
+    languageModelMiddleware: ctx.languageModelMiddleware,
+    usageRecorder: ctx.usageRecorder,
+    streamIdFactory: ctx.streamIdFactory
+  });
+  return { run: () => agent.consume(), drained: () => agent.drained };
+};
+var runWhiteboxChild = async (spec, ctx) => {
+  const { WhiteboxAttackSurfaceAgent } = await import("./core/agents/specialized/whiteboxAttackSurface/index.js");
+  const agent = new WhiteboxAttackSurfaceAgent({
+    codebasePath: spec.codebasePath,
+    attackSurfaceRegistry: spec.attackSurfaceRegistry,
+    model: ctx.model,
+    session: ctx.session,
+    authConfig: ctx.authConfig,
+    abortSignal: ctx.abortSignal,
+    eventBus: ctx.eventBus,
+    subagentId: ctx.subagentId,
+    subagentName: ctx.subagentName,
+    sandbox: ctx.sandbox,
+    backends: ctx.backends,
+    languageModelMiddleware: ctx.languageModelMiddleware,
+    usageRecorder: ctx.usageRecorder,
+    streamIdFactory: ctx.streamIdFactory
+  });
+  return { run: () => agent.consume(), drained: () => agent.drained };
+};
+var runBlackboxChild = async (spec, ctx) => {
+  const { BlackboxAttackSurfaceAgent } = await import("./core/agents/specialized/attackSurface/blackboxAgent.js");
+  const agent = new BlackboxAttackSurfaceAgent({
+    target: spec.target,
+    attackSurfaceRegistry: spec.attackSurfaceRegistry,
+    model: ctx.model,
+    session: ctx.session,
+    authConfig: ctx.authConfig,
+    abortSignal: ctx.abortSignal,
+    eventBus: ctx.eventBus,
+    subagentId: ctx.subagentId,
+    sandbox: ctx.sandbox,
+    backends: ctx.backends,
+    languageModelMiddleware: ctx.languageModelMiddleware,
+    usageRecorder: ctx.usageRecorder,
+    streamIdFactory: ctx.streamIdFactory
+  });
+  return { run: () => agent.consume(), drained: () => agent.drained };
+};
+var runAuthChild = async (spec, ctx) => {
+  const { runAuthenticationAgent } = await import("./chunk-k4rz1yvj.js");
+  return {
+    run: () => runAuthenticationAgent({
+      target: spec.target,
+      authHints: spec.authHints,
+      session: ctx.session,
+      model: ctx.model,
+      authConfig: ctx.authConfig,
+      abortSignal: ctx.abortSignal,
+      eventBus: ctx.eventBus,
+      subagentId: ctx.subagentId,
+      subagentName: ctx.subagentName,
+      environmentVariables: ctx.environmentVariables,
+      secretValues: ctx.secretValues,
+      backends: ctx.backends,
+      languageModelMiddleware: ctx.languageModelMiddleware,
+      usageRecorder: ctx.usageRecorder,
+      streamIdFactory: ctx.streamIdFactory
+    })
+  };
+};
+var runJudgeChild = async (spec, ctx) => {
+  const { judgeFinding } = await import("./core/agents/specialized/findingJudge/index.js");
+  return {
+    run: () => judgeFinding(spec.judgeInput, {
+      model: ctx.model,
+      session: ctx.session,
+      authConfig: ctx.authConfig,
+      abortSignal: ctx.abortSignal,
+      eventBus: ctx.eventBus,
+      subagentId: ctx.subagentId,
+      subagentName: ctx.subagentName,
+      sandbox: ctx.sandbox,
+      backends: ctx.backends,
+      target: spec.target,
+      enableThinking: ctx.enableThinking,
+      thinkingEffort: ctx.thinkingEffort,
+      openAIReasoningEffort: ctx.openAIReasoningEffort,
+      languageModelMiddleware: ctx.languageModelMiddleware,
+      usageRecorder: ctx.usageRecorder,
+      streamIdFactory: ctx.streamIdFactory
+    })
+  };
+};
+var RUNNERS = {
+  pentest: runPentestChild,
+  code: runCodeChild,
+  "whitebox-attack-surface": runWhiteboxChild,
+  "blackbox-attack-surface": runBlackboxChild,
+  authentication: runAuthChild,
+  "finding-judge": runJudgeChild
+};
+function drainBounded(drained, graceMs) {
+  return Promise.race([
+    drained?.catch(() => {}) ?? Promise.resolve(),
+    new Promise((resolve) => {
+      setTimeout(resolve, graceMs).unref?.();
+    })
+  ]);
+}
+
+class InProcessSubagentSpawner {
+  ids;
+  browser;
+  ordinal = 0;
+  constructor(ids = randomSessionIdFactory2, browser) {
+    this.ids = ids;
+    this.browser = browser;
+  }
+  mintChildId(name) {
+    return this.ids.newSessionId(name ?? "subagent", this.ordinal++);
+  }
+  async spawn(opts) {
+    const childId = opts.subagentId ?? this.mintChildId(opts.subagentName);
+    opts.onSpawned?.(childId);
+    const parentSessionId = opts.parentSessionId ?? opts.parentSubagentId ?? opts.runtime.session.id;
+    const lifecycleBase = {
+      subagentId: childId,
+      ...opts.stampChildSessionId ? { sessionId: childId } : {},
+      ...opts.parentSubagentId !== undefined ? { parentSubagentId: opts.parentSubagentId } : {},
+      ...parentSessionId !== undefined ? { parentSessionId } : {}
+    };
+    opts.parentBus?.emit("subagent-spawn", {
+      ...lifecycleBase,
+      name: opts.subagentName,
+      input: opts.lifecycleInput
+    });
+    let handle;
+    try {
+      const childBus = new AgentEventBus2;
+      AgentEventBus2.attachChild(childBus, opts.parentBus, childId);
+      const spec = opts.spec.type === "pentest" && !opts.spec.browserSession && this.browser ? {
+        ...opts.spec,
+        browserSession: this.browser.forChild({
+          subagentId: childId,
+          subagentName: opts.subagentName
+        })
+      } : opts.spec;
+      const runner = RUNNERS[spec.type];
+      handle = await runner(spec, {
+        ...opts.runtime,
+        eventBus: childBus,
+        subagentId: childId,
+        subagentName: opts.subagentName
+      });
+      opts.beforeConsume?.(childBus);
+      const result = await (opts.parentToolCallId && parentSessionId ? runWithNativeRolloutSession2({
+        sessionId: childId,
+        parentSessionId,
+        parentToolCallId: opts.parentToolCallId
+      }, handle.run) : handle.run());
+      await opts.onConsumed?.(result);
+      if (opts.drainGraceMs != null) {
+        await drainBounded(handle.drained?.(), opts.drainGraceMs);
+      }
+      opts.parentBus?.emit("subagent-complete", {
+        ...lifecycleBase,
+        status: opts.resolveStatus?.(result) ?? "completed"
+      });
+      return result;
+    } catch (error) {
+      try {
+        await opts.onError?.(error);
+        if (opts.drainGraceMs != null) {
+          await drainBounded(handle?.drained?.(), opts.drainGraceMs);
+        }
+      } finally {
+        opts.parentBus?.emit("subagent-complete", {
+          ...lifecycleBase,
+          status: "failed"
+        });
+      }
+      throw error;
+    }
+  }
+  spawnMany(items, worker, opts) {
+    return runWithBoundedConcurrency(items, opts.concurrency, worker, opts.abortSignal);
+  }
+}
+var inProcessSubagentSpawner2 = new InProcessSubagentSpawner;
+function createInProcessSubagentSpawner2(seams) {
+  return new InProcessSubagentSpawner(seams?.ids, seams?.browser);
+}
+
+export { runSpawnedPentestWorker2, inProcessSubagentSpawner2, createInProcessSubagentSpawner2, exports_subagentSpawner };

package/build/lib/chunk-vx228eeq.js

@@ -0,0 +1,82 @@
+// src/core/agents/specialized/attackSurface/grpcSchema.ts
+import { z } from "zod";
+var EndpointTransportEnum2 = z.enum([
+  "http",
+  "grpc",
+  "grpc_web",
+  "connect"
+]);
+var GrpcStreamingTypeEnum2 = z.enum([
+  "unary",
+  "server_stream",
+  "client_stream",
+  "bidi"
+]);
+var GrpcSchemaSourceEnum = z.enum([
+  "proto",
+  "reflection",
+  "protoset",
+  "js_bundle",
+  "gateway_derived",
+  "unknown"
+]);
+var GrpcGatewayTypeEnum = z.enum(["rest", "graphql", "connect"]);
+var GrpcEndpointMetadataSchema2 = z.object({
+  serviceFqn: z.string().describe("Fully-qualified service name, e.g. 'account.v1.AccountService'"),
+  method: z.string().describe("RPC method name, e.g. 'GetAccount'"),
+  streamingType: GrpcStreamingTypeEnum2.default("unary"),
+  reflectionAvailable: z.boolean().optional(),
+  schemaSource: GrpcSchemaSourceEnum.optional(),
+  host: z.string().nullish().describe("Authority override; null falls back to the app domain"),
+  frontingGatewayOperation: z.object({
+    gatewayType: GrpcGatewayTypeEnum,
+    operation: z.string()
+  }).nullish()
+});
+var GrpcPentestContextSchema = z.object({
+  transport: z.enum(["grpc", "grpc_web", "connect"]),
+  serviceFqn: z.string(),
+  method: z.string(),
+  streamingType: GrpcStreamingTypeEnum2.optional(),
+  reflectionAvailable: z.boolean().optional(),
+  schemaSource: GrpcSchemaSourceEnum.optional(),
+  host: z.string().nullish().describe("Authority override; null falls back to the app domain"),
+  frontingGatewayOperation: z.object({
+    gatewayType: GrpcGatewayTypeEnum,
+    operation: z.string()
+  }).nullish()
+});
+function deriveGrpcMetadataFromPath(path) {
+  if (!path)
+    return;
+  const wire = path.replace(/^\//, "").split("?")[0];
+  const slash = wire.lastIndexOf("/");
+  if (slash <= 0 || slash === wire.length - 1)
+    return;
+  return { serviceFqn: wire.slice(0, slash), method: wire.slice(slash + 1) };
+}
+function toGrpcPentestContext(transport, grpc, path) {
+  if (!transport || transport === "http")
+    return;
+  const derived = grpc ?? deriveGrpcMetadataFromPath(path);
+  if (!derived)
+    return;
+  return {
+    transport,
+    serviceFqn: derived.serviceFqn,
+    method: derived.method,
+    streamingType: derived.streamingType,
+    reflectionAvailable: derived.reflectionAvailable,
+    schemaSource: derived.schemaSource,
+    host: derived.host,
+    frontingGatewayOperation: derived.frontingGatewayOperation
+  };
+}
+function grpcAuthorityTarget(grpc, path) {
+  if (!grpc?.host)
+    return;
+  const wirePath = path.startsWith("/") ? path : `/${path}`;
+  return `grpc://${grpc.host}${wirePath}`;
+}
+
+export { EndpointTransportEnum2, GrpcStreamingTypeEnum2, GrpcEndpointMetadataSchema2, GrpcPentestContextSchema, toGrpcPentestContext, grpcAuthorityTarget };

package/build/lib/chunk-wchtd611.js

@@ -0,0 +1,186 @@
+import {
+  AuthenticationAgent2,
+  runAuthenticationAgent3
+} from "./chunk-cwj17b1f.js";
+import {
+  __export
+} from "./chunk-n0ba7khr.js";
+
+// src/core/agents/specialized/authenticationAgent/index.ts
+var exports_authenticationAgent = {};
+__export(exports_authenticationAgent, {
+  AUTH_BARRIER_TYPES: () => AUTH_BARRIER_TYPES2,
+  AUTH_METHODS: () => AUTH_METHODS2,
+  AUTH_STATUSES: () => AUTH_STATUSES2,
+  AttemptRegistrationInputSchema: () => AttemptRegistrationInputSchema2,
+  AuthMethodSchema: () => AuthMethodSchema2,
+  AuthenticateInputSchema: () => AuthenticateInputSchema2,
+  AuthenticationAgent: () => AuthenticationAgent2,
+  DetectAuthSchemeInputSchema: () => DetectAuthSchemeInputSchema2,
+  DocumentAuthFlowInputSchema: () => DocumentAuthFlowInputSchema2,
+  ExportAuthForAgentInputSchema: () => ExportAuthForAgentInputSchema2,
+  GetAuthStateInputSchema: () => GetAuthStateInputSchema2,
+  LoadAuthFlowInputSchema: () => LoadAuthFlowInputSchema2,
+  ProbeAuthEndpointsInputSchema: () => ProbeAuthEndpointsInputSchema2,
+  ProbeRegistrationInputSchema: () => ProbeRegistrationInputSchema2,
+  REGISTRATION_BARRIERS: () => REGISTRATION_BARRIERS2,
+  ROLE_LEVELS: () => ROLE_LEVELS2,
+  RefreshSessionInputSchema: () => RefreshSessionInputSchema2,
+  TOKEN_TYPES: () => TOKEN_TYPES2,
+  TokenTypeSchema: () => TokenTypeSchema2,
+  ValidateSessionInputSchema: () => ValidateSessionInputSchema2,
+  runAuthenticationAgent: () => runAuthenticationAgent3
+});
+// src/core/agents/specialized/authenticationAgent/types.ts
+import { z } from "zod";
+var AUTH_METHODS2 = [
+  "form",
+  "json",
+  "basic",
+  "bearer",
+  "oauth",
+  "api_key"
+];
+var TOKEN_TYPES2 = [
+  "cookie",
+  "jwt",
+  "bearer",
+  "api_key",
+  "session_id"
+];
+var AUTH_STATUSES2 = [
+  "pending",
+  "authenticating",
+  "active",
+  "expired",
+  "failed"
+];
+var ROLE_LEVELS2 = ["guest", "user", "admin", "superadmin"];
+var AUTH_BARRIER_TYPES2 = [
+  "captcha",
+  "mfa",
+  "oauth_consent",
+  "rate_limit",
+  "invite_code",
+  "admin_approval",
+  "email_verification",
+  "phone_verification",
+  "unknown"
+];
+var REGISTRATION_BARRIERS2 = [
+  "invite_code",
+  "admin_approval",
+  "captcha",
+  "email_verification",
+  "phone_verification",
+  "closed"
+];
+var AuthMethodSchema2 = z.enum(AUTH_METHODS2);
+var TokenTypeSchema2 = z.enum(TOKEN_TYPES2);
+var DetectAuthSchemeInputSchema2 = z.object({
+  endpoint: z.string().describe("Target endpoint URL to analyze for auth requirements"),
+  toolCallDescription: z.string().describe("Why you are detecting auth scheme for this endpoint")
+});
+var AuthenticateInputSchema2 = z.object({
+  loginUrl: z.string().describe("Login endpoint URL"),
+  method: z.enum(["form_post", "json_post", "basic_auth", "bearer", "api_key"]).describe("Authentication method to use"),
+  credentials: z.object({
+    username: z.string().optional().describe("Username or email"),
+    password: z.string().optional().describe("Password"),
+    apiKey: z.string().optional().describe("API key if using api_key method"),
+    customFields: z.record(z.string(), z.string()).optional().describe("Additional fields required for authentication")
+  }),
+  usernameField: z.string().default("username").describe("Form field name for username (e.g., 'email', 'user')"),
+  passwordField: z.string().default("password").describe("Form field name for password"),
+  csrfToken: z.string().optional().describe("CSRF token if required"),
+  toolCallDescription: z.string().describe("Why you are authenticating with these credentials")
+});
+var ValidateSessionInputSchema2 = z.object({
+  testEndpoint: z.string().describe("Protected endpoint to test access"),
+  expectedStatus: z.number().default(200).describe("Expected HTTP status code for valid session"),
+  toolCallDescription: z.string().describe("Why you are validating the session"),
+  providedTokens: z.object({
+    bearerToken: z.string().optional().describe("Bearer/JWT token to test"),
+    cookies: z.string().optional().describe("Cookie string to test"),
+    customHeaders: z.record(z.string(), z.string()).optional().describe("Custom headers to include (e.g., X-API-Key, X-Auth-Token)")
+  }).optional().describe("Pre-existing tokens to validate. If provided, these will be tested and stored on success.")
+});
+var RefreshSessionInputSchema2 = z.object({
+  refreshEndpoint: z.string().optional().describe("Token refresh endpoint URL"),
+  useOriginalCredentials: z.boolean().default(true).describe("Whether to re-authenticate with original credentials if refresh fails"),
+  toolCallDescription: z.string().describe("Why you are refreshing the session")
+});
+var GetAuthStateInputSchema2 = z.object({
+  toolCallDescription: z.string().describe("Why you need to check the current auth state")
+});
+var ExportAuthForAgentInputSchema2 = z.object({
+  format: z.enum(["headers", "curl", "poc_script"]).default("headers").describe("Export format for auth information"),
+  toolCallDescription: z.string().describe("Why you are exporting auth for another agent")
+});
+var LoadAuthFlowInputSchema2 = z.object({
+  targetHost: z.string().describe("Target host to load auth flow for"),
+  toolCallDescription: z.string().describe("Why you are loading the documented auth flow")
+});
+var DocumentAuthFlowInputSchema2 = z.object({
+  targetHost: z.string().describe("Target host this flow applies to"),
+  scheme: z.object({
+    method: AuthMethodSchema2.describe("Authentication method discovered"),
+    loginUrl: z.string().describe("Login endpoint URL"),
+    logoutUrl: z.string().optional().describe("Logout endpoint URL if discovered"),
+    refreshUrl: z.string().optional().describe("Token refresh endpoint URL if discovered")
+  }),
+  fields: z.object({
+    usernameField: z.string().describe("Form field name for username"),
+    passwordField: z.string().describe("Form field name for password"),
+    csrfField: z.string().optional().describe("CSRF token field name if required"),
+    additionalFields: z.record(z.string(), z.string()).optional().describe("Other required fields discovered")
+  }),
+  csrfExtraction: z.object({
+    method: z.enum(["meta_tag", "input_hidden", "cookie", "header"]).describe("How to extract CSRF token"),
+    selector: z.string().optional().describe("CSS selector if meta_tag or input_hidden"),
+    cookieName: z.string().optional().describe("Cookie name if from cookie"),
+    headerName: z.string().optional().describe("Header name if from response header")
+  }).optional(),
+  tokenExtraction: z.object({
+    accessToken: z.object({
+      location: z.enum(["header", "body", "cookie"]),
+      path: z.string().optional().describe("JSON path if in body"),
+      headerName: z.string().optional(),
+      cookieName: z.string().optional()
+    }).optional(),
+    refreshToken: z.object({
+      location: z.enum(["header", "body", "cookie"]),
+      path: z.string().optional(),
+      headerName: z.string().optional(),
+      cookieName: z.string().optional()
+    }).optional(),
+    sessionCookie: z.object({
+      name: z.string().describe("Session cookie name")
+    }).optional()
+  }),
+  browserFlow: z.object({
+    required: z.boolean().describe("Whether browser automation was needed"),
+    reason: z.enum(["spa", "oauth", "captcha", "mfa"]).optional().describe("Why browser was required"),
+    loginFormSelector: z.string().optional(),
+    submitButtonSelector: z.string().optional(),
+    postLoginIndicator: z.string().optional().describe("Element that appears after successful login"),
+    usernameInputSelector: z.string().optional(),
+    passwordInputSelector: z.string().optional()
+  }).optional(),
+  notes: z.array(z.string()).optional().describe("Notes for future runs (rate limits, quirks, etc.)"),
+  toolCallDescription: z.string().describe("Why you are documenting this auth flow")
+});
+var ProbeAuthEndpointsInputSchema2 = z.object({
+  baseUrl: z.string().describe("Base URL of the target (e.g., http://localhost:3002)"),
+  toolCallDescription: z.string().describe("Why you are probing for auth endpoints")
+});
+var ProbeRegistrationInputSchema2 = z.object({
+  baseUrl: z.string().describe("Base URL of the target (e.g., http://localhost:3002)"),
+  toolCallDescription: z.string().describe("Why you are probing for registration functionality")
+});
+var AttemptRegistrationInputSchema2 = z.object({
+  registrationUrl: z.string().describe("Registration endpoint URL discovered from probe_registration"),
+  requiredFields: z.record(z.string(), z.string()).describe("Required field values (e.g., { email: 'test@example.com', username: 'testuser', password: 'Test123!' })"),
+  toolCallDescription: z.string().describe("Why you are attempting registration")
+});
+export { AUTH_METHODS2, TOKEN_TYPES2, AUTH_STATUSES2, ROLE_LEVELS2, AUTH_BARRIER_TYPES2, REGISTRATION_BARRIERS2, AuthMethodSchema2, TokenTypeSchema2, DetectAuthSchemeInputSchema2, AuthenticateInputSchema2, ValidateSessionInputSchema2, RefreshSessionInputSchema2, GetAuthStateInputSchema2, ExportAuthForAgentInputSchema2, LoadAuthFlowInputSchema2, DocumentAuthFlowInputSchema2, ProbeAuthEndpointsInputSchema2, ProbeRegistrationInputSchema2, AttemptRegistrationInputSchema2, exports_authenticationAgent };