const std = @import("std");const tool_dispatch = @import("../../core/tooling/tool_dispatch.zig");const url_policy = @import("url_policy.zig"); const Allocator = std.mem.Allocator; const whitespace = " \t\r\n"; pub const Input = struct {    url: []u8,     pub fn deinit(self: *Input, alloc: Allocator) void {        alloc.free(self.url);        self.* = .{ .url = &.{} };    }}; pub fn decode(ctx: tool_dispatch.DispatchContext, args_json: []const u8) tool_dispatch.DispatchError!tool_dispatch.DecodeResult {    var parsed = std.json.parseFromSlice(std.json.Value, ctx.allocator, args_json, .{}) catch {        return .{ .failure = try ctx.allocator.dupe(u8, "web_fetch arguments must be valid JSON") };    };    defer parsed.deinit();     if (parsed.value != .object) {        return .{ .failure = try ctx.allocator.dupe(u8, "web_fetch arguments must be an object") };    }     var it = parsed.value.object.iterator();    while (it.next()) |entry| {        if (std.mem.eql(u8, entry.key_ptr.*, "url")) continue;        return .{ .failure = try std.fmt.allocPrint(ctx.allocator, "web_fetch field \"{s}\" is not allowed", .{entry.key_ptr.*}) };    }     const url_value = parsed.value.object.get("url") orelse {        return .{ .failure = try ctx.allocator.dupe(u8, "web_fetch field \"url\" is required") };    };    if (url_value != .string) {        return .{ .failure = try ctx.allocator.dupe(u8, "web_fetch field \"url\" must be a string") };    }     const input = try ctx.allocator.create(Input);    errdefer ctx.allocator.destroy(input);    const url = try ctx.allocator.dupe(u8, url_value.string);    errdefer ctx.allocator.free(url);    input.* = .{        .url = url,    };    errdefer input.deinit(ctx.allocator);     return .{ .input = .{ .ptr = input, .deinit_fn = inputDeinit } };} pub fn validate(ctx: tool_dispatch.DispatchContext, erased: tool_dispatch.ToolInput) tool_dispatch.DispatchError!?[]u8 {    const input = erased.as(Input);    const trimmed = std.mem.trim(u8, input.url, whitespace);    if (!std.mem.eql(u8, input.url, trimmed)) {        const owned = try ctx.allocator.dupe(u8, trimmed);        ctx.allocator.free(input.url);        input.url = owned;    }     var normalized = url_policy.normalize(ctx.allocator, input.url) catch |err| {        return try ctx.allocator.dupe(u8, urlValidationMessage(err));    };    defer normalized.deinit(ctx.allocator);    if (!std.mem.eql(u8, input.url, normalized.retrieval_url)) {        const owned = try ctx.allocator.dupe(u8, normalized.retrieval_url);        ctx.allocator.free(input.url);        input.url = owned;    }     return null;} pub fn readsOnly(_: tool_dispatch.ToolInput) bool {    return true;} pub fn isIrreversible(_: tool_dispatch.ToolInput) bool {    return false;} fn inputDeinit(ptr: *anyopaque, alloc: Allocator) void {    const input: *Input = @ptrCast(@alignCast(ptr));    input.deinit(alloc);    alloc.destroy(input);} fn urlValidationMessage(err: url_policy.Error) []const u8 {    return switch (err) {        error.EmptyUrl => "web_fetch field \"url\" must not be empty",        error.UrlTooLong => "web_fetch field \"url\" must be at most 2000 bytes",        error.UnsupportedScheme => "web_fetch url must start with http:// or https://",        error.MissingHost => "web_fetch url must include a host",        error.CredentialedUrl => "web_fetch refuses credential-bearing URLs",        error.NonPublicAddress,        error.SingleLabelHost,        => "web_fetch only fetches known public HTTP(S) URLs",        error.MalformedPercentEncoding,        error.PercentEncodedHost,        error.UnicodeHost,        error.ControlByte,        error.InvalidPort,        error.InvalidIpv4,        error.ScopeIdRejected,        error.MalformedHost,        error.MalformedLocation,        error.PortChanged,        error.ProtocolChanged,        error.RequestTargetWhitespace,        error.OutOfMemory,        error.WriteFailed,        => "web_fetch url is malformed",    };}