1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
const std = @import("std");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
// Parse -p flag
const args = try std.process.argsAlloc(allocator);
defer std.process.argsFree(allocator, args);
var prompt: ?[]const u8 = null;
var i: usize = 1;
while (i < args.len) : (i += 1) {
if (std.mem.eql(u8, args[i], "-p") and i + 1 < args.len) {
i += 1;
prompt = args[i];
}
}
const prompt_str = prompt orelse @panic("Prompt must not be empty");
const api_key = std.posix.getenv("OPENROUTER_API_KEY") orelse @panic("OPENROUTER_API_KEY is not set");
const base_url = std.posix.getenv("OPENROUTER_BASE_URL") orelse "https://openrouter.ai/api/v1";
// Build request body
var body_out: std.io.Writer.Allocating = .init(allocator);
defer body_out.deinit();
var jw: std.json.Stringify = .{ .writer = &body_out.writer };
try jw.write(.{
.model = "anthropic/claude-haiku-4.5",
.messages = &[_]struct { role: []const u8, content: []const u8 }{
.{ .role = "user", .content = prompt_str },
},
.tools = &[_]struct {
type: []const u8,
function: struct {
name: []const u8,
description: []const u8,
parameters: struct {
type: []const u8,
properties: struct {
file_path: struct {
type: []const u8,
description: []const u8,
},
},
required: []const []const u8,
},
},
}{
.{
.type = "function",
.function = .{
.name = "Read",
.description = "Read and return the contents of a file",
.parameters = .{
.type = "object",
.properties = .{
.file_path = .{
.type = "string",
.description = "The path to the file to read",
},
},
.required = &[_][]const u8{"file_path"},
},
},
},
},
});
const body = body_out.written();
// Build URL and auth header
const url_str = try std.fmt.allocPrint(allocator, "{s}/chat/completions", .{base_url});
defer allocator.free(url_str);
const auth_value = try std.fmt.allocPrint(allocator, "Bearer {s}", .{api_key});
defer allocator.free(auth_value);
// Make HTTP request
var client: std.http.Client = .{ .allocator = allocator };
defer client.deinit();
var response_out: std.io.Writer.Allocating = .init(allocator);
defer response_out.deinit();
_ = try client.fetch(.{
.location = .{ .url = url_str },
.method = .POST,
.payload = body,
.extra_headers = &.{
.{ .name = "content-type", .value = "application/json" },
.{ .name = "authorization", .value = auth_value },
},
.response_writer = &response_out.writer,
});
const response_body = response_out.written();
// Parse response
const parsed = try std.json.parseFromSlice(std.json.Value, allocator, response_body, .{});
defer parsed.deinit();
const choices = parsed.value.object.get("choices") orelse @panic("No choices in response");
if (choices.array.items.len == 0) {
@panic("No choices in response");
}
// You can use print statements as follows for debugging, they'll be visible when running tests.
std.debug.print("Logs from your program will appear here!\n", .{});
// TODO: Uncomment the lines below to pass the first stage
const content = choices.array.items[0].object.get("message").?.object.get("content").?.string;
try std.fs.File.stdout().writeAll(content);
}
|
