@artinet/fleet 0.1.0-alpha.1

package/dist/src/routes/create/index.js

@@ -0,0 +1,3 @@
+import * as armada from "@artinet/armada";
+export const CreateAgent = armada.CreateAgent;
+export const CreateAgentRequestSchema = armada.CreateAgentRequestSchema;

package/dist/src/routes/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./create/index.js";
+export * from "./request/index.js";

package/dist/src/routes/index.js

@@ -0,0 +1,2 @@
+export * from "./create/index.js";
+export * from "./request/index.js";

package/dist/src/routes/request/implementation/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./request.js";
+export * from "./invoke.js";
+export * from "./load.js";
+export * from "./test-invoke.js";

package/dist/src/routes/request/implementation/index.js

@@ -0,0 +1,4 @@
+export * from "./request.js";
+export * from "./invoke.js";
+export * from "./load.js";
+export * from "./test-invoke.js";

package/dist/src/routes/request/implementation/invoke.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod/v4";
+import * as sdk from "@artinet/sdk";
+import { RequestAgentRoute, invokeFunction } from "../types/definitions.js";
+export declare const invoke: (type: "success" | "error" | "stream", request: RequestAgentRoute["request"], invocable: Promise<sdk.A2A.ResponseResult | sdk.A2A.AgentCard> | AsyncIterable<sdk.A2A.Update>) => Promise<RequestAgentRoute["response"] | null>;
+export declare const callAgent: (request: RequestAgentRoute["request"], agent: sdk.A2A.Service, params?: NonNullable<z.output<typeof sdk.A2A.RequestParamSchema>> | {
+    validation: string;
+}) => Promise<RequestAgentRoute["response"] | null>;
+export declare const invokeAgent: invokeFunction;

package/dist/src/routes/request/implementation/invoke.js

@@ -0,0 +1,150 @@
+import * as sdk from "@artinet/sdk";
+import { assert } from "console";
+function isClient(agent) {
+    return agent instanceof sdk.A2AClient;
+}
+export const invoke = async (type, request, invocable) => {
+    let result = undefined;
+    try {
+        sdk.logger.info(`invoke:${request.method}`);
+        sdk.logger.debug(`invoke:${request.method}`, { params: request.params });
+        result = await invocable;
+        sdk.logger.debug(`invocation completed:${request.method}`, { result });
+    }
+    catch (error) {
+        sdk.logger.error(`invocation error:${request.method}:error:${JSON.stringify(error, null, 2)}`, { error });
+        return {
+            type: "error",
+            error: error,
+        };
+    }
+    if (!result) {
+        sdk.logger.error(`invocation failed:${request.method}`, { result });
+        return {
+            type: "error",
+            error: sdk.INTERNAL_ERROR({
+                message: "Internal error: No result from invocation",
+                method: request.method,
+            }),
+        };
+    }
+    if (type === "success") {
+        return {
+            type: "success",
+            result: result,
+        };
+    }
+    if (type === "stream") {
+        return {
+            type: "stream",
+            stream: result,
+        };
+    }
+    return {
+        type: "error",
+        error: sdk.INTERNAL_ERROR({
+            message: "Internal error: Invalid result type",
+            method: request.method,
+        }),
+    };
+};
+export const callAgent = async (request, agent, params = { validation: "no params provided" }) => {
+    switch (request.method) {
+        case "message/send": {
+            return await invoke("success", request, agent.sendMessage(params));
+        }
+        case "message/stream": {
+            return await invoke("stream", request, agent.streamMessage(params));
+        }
+        case "task/resubscribe": {
+            return await invoke("stream", request, agent.resubscribe(params));
+        }
+        case "task/get": {
+            return await invoke("success", request, agent.getTask(params));
+        }
+        case "task/cancel": {
+            return await invoke("success", request, agent.cancelTask(params));
+        }
+        case "task/pushNotificationConfig/set": {
+            if (!isClient(agent)) {
+                throw sdk.PUSH_NOTIFICATION_NOT_SUPPORTED({
+                    data: {
+                        message: "Push notifications are not supported for clients",
+                        method: request.method,
+                    },
+                });
+            }
+            return await invoke("success", request, agent.setTaskPushNotification(params));
+        }
+        case "task/pushNotificationConfig/get": {
+            if (!isClient(agent)) {
+                throw sdk.PUSH_NOTIFICATION_NOT_SUPPORTED({
+                    data: {
+                        message: "Push notifications are not supported for clients",
+                        method: request.method,
+                    },
+                });
+            }
+            return await invoke("success", request, agent.getTaskPushNotification(params));
+        }
+        case "task/pushNotificationConfig/list": {
+            throw sdk.PUSH_NOTIFICATION_NOT_SUPPORTED({
+                data: {
+                    message: "Push notifications are not supported for clients",
+                    method: request.method,
+                },
+            });
+        }
+        case "task/pushNotificationConfig/delete": {
+            throw sdk.PUSH_NOTIFICATION_NOT_SUPPORTED({
+                data: {
+                    message: "Push notifications are not supported for clients",
+                    method: request.method,
+                },
+            });
+        }
+        case "agentcard/get":
+        case "agent/getAuthenticatedExtendedCard": {
+            return await invoke("success", request, agent.getAgentCard());
+        }
+        default:
+            throw sdk.METHOD_NOT_FOUND({
+                data: {
+                    message: "Method not found",
+                    method: request.method,
+                },
+            });
+    }
+};
+export const invokeAgent = async (request, _agent) => {
+    sdk.logger.info("Invoking agent: " + request.method);
+    const _params = await sdk.validateSchema(sdk.A2A.RequestParamSchema, request.params);
+    const params = _params ?? { validation: "no params provided" };
+    sdk.logger.debug(`invokeAgent[${request.method}]: incoming params: ${sdk.formatJson(params)}`);
+    /* Support for A2AClient requests TBD */
+    assert(!isClient(_agent), "A2AClient requests are not supported");
+    //TODO: This proxy pattern is temporary until we align the A2AClient with the latest protocol changes
+    let agent = _agent;
+    if (isClient(_agent)) {
+        sdk.logger.debug(`invokeAgent[${request.method}]: creating proxy client`);
+        agent = {
+            ..._agent,
+            streamMessage: async function* (params) {
+                yield* _agent.sendStreamingMessage(params);
+            },
+            resubscribe: async function* (params) {
+                yield* _agent.resubscribeTask(params);
+            },
+        };
+    }
+    const response = await callAgent(request, agent, params);
+    if (!response) {
+        throw sdk.INTERNAL_ERROR({
+            data: {
+                message: "Internal error: No response from agent",
+                method: request.method,
+            },
+        });
+    }
+    return response;
+};

package/dist/src/routes/request/implementation/load.d.ts

@@ -0,0 +1,2 @@
+import { loadFunction } from "../types/definitions.js";
+export declare const loadAgent: loadFunction;

package/dist/src/routes/request/implementation/load.js

@@ -0,0 +1,50 @@
+import { orc8 } from "orc8";
+import { openaiProvider } from "orc8/openai";
+import * as sdk from "@artinet/sdk";
+import { Runtime } from "@artinet/types";
+const DEFAULT_INSTRUCTIONS = "You are a helpful assistant that can use tools and agents to fulfill requests.";
+const requiredAgentsNotLoaded = (config, context) => {
+    return ((!context.agents || !context.agents.length) &&
+        config.agentIds &&
+        config.agentIds.length > 0);
+};
+const missingAgents = (config, context) => {
+    return (config.agentIds?.filter((id) => !context.agents?.[id]).join(", ") ?? null);
+};
+export const loadAgent = async (config, context, provider = process.env.OPENAI_API_KEY
+    ? openaiProvider({
+        apiKey: process.env.OPENAI_API_KEY,
+        baseURL: context?.inferenceProviderUrl,
+    })
+    : undefined) => {
+    if (!context) {
+        throw sdk.INTERNAL_ERROR({
+            message: "Context not found",
+        });
+    }
+    const o8 = orc8.create({
+        ...config,
+        modelId: config.modelId ?? "gpt-4o",
+        instructions: config.instructions ??
+            context.defaultInstructions ??
+            DEFAULT_INSTRUCTIONS,
+        provider,
+    });
+    if (requiredAgentsNotLoaded(config, context)) {
+        throw sdk.INTERNAL_ERROR({
+            message: `Agents not found: ${missingAgents(config, context)}`,
+        });
+    }
+    if (missingAgents(config, context)) {
+        sdk.logger.warn(`Missing agents: ${missingAgents(config, context)}`);
+    }
+    Object.values(context.agents ?? {}).forEach((agent) => o8.add(agent));
+    config.services
+        .filter(Runtime.isToolInstance)
+        .filter((service) => Runtime.MCPStdioArgumentsSchema.safeParse(service.arguments).success)
+        .map((service) => service.arguments)
+        .forEach((args) => {
+        o8.add(args);
+    });
+    return o8.agent;
+};

package/dist/src/routes/request/implementation/request.d.ts

@@ -0,0 +1,2 @@
+import { RequestAgentRoute } from "../types/definitions.js";
+export declare const requestImplementation: RequestAgentRoute["implementation"];

package/dist/src/routes/request/implementation/request.js

@@ -0,0 +1,28 @@
+import { AgentConfigurationSchema } from "agent-def";
+import * as sdk from "@artinet/sdk";
+export const requestImplementation = async (request, context) => {
+    if (!context.target) {
+        throw sdk.INTERNAL_ERROR({
+            message: `Agent ${context.agentId} not found: ${sdk.formatJson(context.found?.error ?? { error: "Unknown error" })}`,
+            method: request.method,
+        });
+    }
+    const agentConfig = await sdk.validateSchema(AgentConfigurationSchema, context.target);
+    const agent = await context.load(agentConfig, context);
+    if (!agent) {
+        throw sdk.INTERNAL_ERROR({
+            data: {
+                message: `Agent ${context.agentId} failed to load`,
+            },
+        });
+    }
+    const response = await context.invoke(request, agent, context);
+    if (!response) {
+        throw sdk.INTERNAL_ERROR({
+            data: {
+                message: `Agent ${context.agentId} failed to invoke`,
+            },
+        });
+    }
+    return response;
+};

package/dist/src/routes/request/implementation/test-invoke.d.ts

@@ -0,0 +1,3 @@
+import { TestAgentRoute } from "../types/definitions.js";
+import { Agent } from "../types/definitions.js";
+export declare const testInvoke: (request: TestAgentRoute["request"], _agent: Agent) => Promise<TestAgentRoute["response"] | null>;

package/dist/src/routes/request/implementation/test-invoke.js

@@ -0,0 +1,42 @@
+import * as sdk from "@artinet/sdk";
+import { TestRequestSchema } from "../types/definitions.js";
+import { v4 as uuidv4 } from "uuid";
+const getId = (request) => {
+    let id = request.id ?? request.agentId;
+    if (!id) {
+        sdk.logger.debug("No id provided, generating a new one");
+        id = uuidv4();
+    }
+    return id;
+};
+export const testInvoke = async (request, _agent) => {
+    if (_agent instanceof sdk.A2AClient) {
+        throw sdk.INVALID_REQUEST({
+            message: "Test agent requests are not supported for A2AClients",
+            id: request.id,
+            agentId: request.agentId,
+        });
+    }
+    const id = getId(request);
+    sdk.logger.info("Invoking test agent: ", { id });
+    const testRequest = await sdk.validateSchema(TestRequestSchema, request.params);
+    if (!testRequest || !testRequest.tests || testRequest.tests.length === 0) {
+        throw sdk.INVALID_PARAMS({
+            message: "Invalid parameters for testing: no tests provided",
+            id,
+            agentId: request.agentId,
+            tests: testRequest.tests,
+        });
+    }
+    sdk.logger.debug(`invokeTestAgent[${id}]: incoming tests: ${sdk.formatJson(testRequest.tests)}`);
+    const asyncIterable = async function* () {
+        for (const test of testRequest.tests) {
+            sdk.logger.info(`testInvoke[${id}]: starting test: ${test.message.messageId}`);
+            yield* await _agent.streamMessage(test);
+        }
+    };
+    return {
+        type: "stream",
+        stream: asyncIterable(),
+    };
+};

package/dist/src/routes/request/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./implementation/index.js";
+export * from "./interceptors/index.js";
+export * from "./types/index.js";
+export * from "./request.js";

package/dist/src/routes/request/index.js

@@ -0,0 +1,4 @@
+export * from "./implementation/index.js";
+export * from "./interceptors/index.js";
+export * from "./types/index.js";
+export * from "./request.js";

package/dist/src/routes/request/interceptors/fetch-agent.d.ts

@@ -0,0 +1,2 @@
+import { RequestAgentRoute } from "../types/definitions.js";
+export declare const FetchAgent: RequestAgentRoute["intercept"];

package/dist/src/routes/request/interceptors/fetch-agent.js

@@ -0,0 +1,26 @@
+import * as armada from "@artinet/armada";
+import { AgentConfigurationSchema } from "agent-def";
+import * as sdk from "@artinet/sdk";
+export const FetchAgent = {
+    trigger: ({ context }) => !context.target,
+    action: async ({ request, context, }) => armada
+        .TryFindBase({ request, context }, {
+        uri: context.agentId,
+        throwNotFound: true,
+        storage: context.storage,
+        find: armada.FindAgent,
+    })
+        .then(async (request) => {
+        if (!context.found) {
+            throw sdk.INTERNAL_ERROR({
+                data: {
+                    message: `agent ${context.agentId} not found`,
+                },
+            });
+        }
+        context.target = await sdk.validateSchema(AgentConfigurationSchema, Object.values(context.found.results)[0]);
+        context.found = undefined;
+        return request;
+    }),
+    phase: armada.Phase.REQUEST,
+};

package/dist/src/routes/request/interceptors/get-agents.d.ts

@@ -0,0 +1,2 @@
+import { RequestAgentRoute } from "../types/definitions.js";
+export declare const GetAgents: RequestAgentRoute["intercept"];

package/dist/src/routes/request/interceptors/get-agents.js

@@ -0,0 +1,38 @@
+import { AgentConfigurationSchema } from "agent-def";
+import * as armada from "@artinet/armada";
+import * as sdk from "@artinet/sdk";
+export const GetAgents = {
+    trigger: ({ context }) => !!context.target && (context.target.agentIds?.length ?? 0) > 0,
+    action: async ({ request, context, }) => {
+        for (const agentId of context.target?.agentIds ?? []) {
+            await armada.TryFindBase({ request, context }, {
+                uri: agentId,
+                throwNotFound: false,
+                storage: context.storage,
+                find: armada.FindAgent,
+            });
+            if (!context.found || !context.found.results[agentId]) {
+                continue;
+            }
+            const agentConfig = await sdk
+                .validateSchema(AgentConfigurationSchema, context.found.results[agentId])
+                .catch((error) => {
+                sdk.logger.error(`Failed to validate agent configuration: ${agentId}`, error);
+                return null;
+            });
+            if (!agentConfig) {
+                continue;
+            }
+            const agent = await context.load(agentConfig, context);
+            if (!agent) {
+                continue;
+            }
+            context.agents = {
+                ...context.agents,
+                [agentId]: agent,
+            };
+        }
+        return request;
+    },
+    phase: armada.Phase.REQUEST,
+};

package/dist/src/routes/request/interceptors/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./fetch-agent.js";
+export * from "./get-agents.js";

package/dist/src/routes/request/interceptors/index.js

@@ -0,0 +1,2 @@
+export * from "./fetch-agent.js";
+export * from "./get-agents.js";

package/dist/src/routes/request/request.d.ts

@@ -0,0 +1,8 @@
+import { RequestAgentRoute, TestAgentRoute } from "./types/definitions.js";
+export declare const requestAgent: (request: RequestAgentRoute["request"], context: RequestAgentRoute["context"], requestFn?: RequestAgentRoute["implementation"]) => Promise<RequestAgentRoute["response"]>;
+export declare const RequestAgent: RequestAgentRoute["implementation"];
+/**
+ * Test agent implementation.
+ * @note Similar to RequestAgent, but skips the FetchAgent intercept and uses the testInvoke function that returns a stream of updates.
+ */
+export declare const TestAgent: TestAgentRoute["implementation"];

package/dist/src/routes/request/request.js

@@ -0,0 +1,16 @@
+import * as armada from "@artinet/armada";
+import { FetchAgent } from "./interceptors/fetch-agent.js";
+import { GetAgents } from "./interceptors/get-agents.js";
+import { requestImplementation } from "./implementation/request.js";
+export const requestAgent = (request, context, requestFn = requestImplementation) => armada.entry({
+    request,
+    implementation: requestFn,
+    intercepts: [FetchAgent, GetAgents],
+    context,
+});
+export const RequestAgent = (request, context) => requestAgent(request, context, requestImplementation);
+/**
+ * Test agent implementation.
+ * @note Similar to RequestAgent, but skips the FetchAgent intercept and uses the testInvoke function that returns a stream of updates.
+ */
+export const TestAgent = (request, context) => requestAgent(request, context, requestImplementation);