copilot-sdk-cpp/src/factory.cpp at main · 0xeb/copilot-sdk-cpp · GitHub

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
// Copyright (c) 2025 Elias Bachaalany
// SPDX-License-Identifier: MIT

#include <copilot/factory.hpp>
#include <copilot/session.hpp>

namespace copilot
{

FactoryHandle define_factory(
    json meta,
    std::function<json(const json& context)> run)
{
    if (!meta.is_object() || !meta.contains("name") ||
        !meta["name"].is_string() || meta["name"].get<std::string>().empty())
    {
        throw std::invalid_argument("factory metadata requires a non-empty name");
    }
    if (!run)
        throw std::invalid_argument("factory run handler is required");
    return FactoryHandle{std::move(meta), std::move(run)};
}

std::future<generated::api::FactoryExecuteResult> SessionFactoryApi::run(
    const std::string& name, json options)
{
    options["name"] = name;
    return session_.invoke_typed<generated::api::FactoryExecuteResult>(
        "session.factory.run", std::move(options));
}

std::future<generated::api::FactoryResumeResult> SessionFactoryApi::resume(
    const std::string& run_id, json options)
{
    options["runId"] = run_id;
    return session_.invoke_typed<generated::api::FactoryResumeResult>(
        "session.factory.resume", std::move(options));
}

std::future<generated::api::FactoryRunResult> SessionFactoryApi::get_run(
    const std::string& run_id)
{
    return session_.invoke_typed<generated::api::FactoryRunResult>(
        "session.factory.getRun", json{{"runId", run_id}});
}

std::future<generated::api::FactoryListRunsResult> SessionFactoryApi::list_runs(
    json options)
{
    return session_.invoke_typed<generated::api::FactoryListRunsResult>(
        "session.factory.listRuns", std::move(options));
}

std::future<generated::api::FactoryRunDetail> SessionFactoryApi::get_run_detail(
    const std::string& run_id)
{
    return session_.invoke_typed<generated::api::FactoryRunDetail>(
        "session.factory.getRunDetail", json{{"runId", run_id}});
}

std::future<generated::api::FactoryProgressPage>
SessionFactoryApi::get_run_progress(
    const std::string& run_id, json options)
{
    options["runId"] = run_id;
    return session_.invoke_typed<generated::api::FactoryProgressPage>(
        "session.factory.getRunProgress", std::move(options));
}

std::future<generated::api::FactoryRunResult> SessionFactoryApi::cancel(
    const std::string& run_id)
{
    return session_.invoke_typed<generated::api::FactoryRunResult>(
        "session.factory.cancel", json{{"runId", run_id}});
}

std::future<generated::api::FactoryRunResult> SessionFactoryApi::run_from_tool(
    json params)
{
    return session_.invoke_typed<generated::api::FactoryRunResult>(
        "session.factory.runFromTool", std::move(params));
}

std::future<generated::api::FactoryResumeResult>
SessionFactoryApi::resume_from_tool(json params)
{
    return session_.invoke_typed<generated::api::FactoryResumeResult>(
        "session.factory.resumeFromTool", std::move(params));
}

} // namespace copilot