ankka 0.7.1 → 0.9.0

package/dist/service.js

@@ -11,8 +11,9 @@ import { View } from "./view.js";
 import { Consumer } from "./consumer.js";
 import { TimedAction } from "./timedAction.js";
 import { Agent } from "./agent.js";
+import { AutonomousAgent, COMPLETE_TASK, FAIL_TASK } from "./autonomous.js";
 import { Endpoint } from "./endpoint.js";
-import { Acl as AclValues } from "./routes.js";
+import { isAcl } from "./routes.js";
 import { ComponentClient } from "./client.js";
 import { Server } from "./server/server.js";
 import { renderSpec } from "./spec.js";
@@ -100,6 +101,8 @@ export class ServiceBuilder {
                 add(registerTimedAction(cls, problems), cls);
             else if (extendsBase(cls, Agent))
                 add(registerAgent(cls, problems), cls);
+            else if (extendsBase(cls, AutonomousAgent))
+                add(registerAutonomousAgent(cls, problems), cls);
             else if (extendsBase(cls, Endpoint)) {
                 const ep = cls;
                 if (typeof ep.prefix === "string") {
@@ -117,7 +120,7 @@ export class ServiceBuilder {
                 }
             }
             else {
-                problems.push(`${nameOf(cls)} is not a component class: it must extend EventSourcedEntity, KeyValueEntity, Workflow, View, Consumer, TimedAction, Agent or Endpoint`);
+                problems.push(`${nameOf(cls)} is not a component class: it must extend EventSourcedEntity, KeyValueEntity, Workflow, View, Consumer, TimedAction, Agent, AutonomousAgent or Endpoint`);
             }
         }
         if (problems.length > 0)
@@ -314,6 +317,44 @@ function registerAgent(cls, problems) {
         return undefined;
     return Object.freeze({ kind: "agent", id: cls.componentId, cls, handlers, tools, guardrails, role: cls.role ?? "", maxToolCallSteps });
 }
+function registerAutonomousAgent(cls, problems) {
+    const { fail, ok } = checker(cls, problems);
+    requireId(cls, fail);
+    if (typeof cls.description !== "string" || cls.description.trim() === "")
+        fail("a description is required");
+    const tools = new Map();
+    for (const [property, t] of Object.entries(cls.tools ?? {})) {
+        if (typeof t !== "object" || t === null || typeof t.name !== "string" || typeof t.run !== "function") {
+            fail(`tools.${property} is not a tool: declare it with tool(name, description, input, run)`);
+            continue;
+        }
+        if (t.name === COMPLETE_TASK || t.name === FAIL_TASK)
+            fail(`tool name ${JSON.stringify(t.name)} is reserved`);
+        if (tools.has(t.name))
+            fail(`two tools declare the name ${JSON.stringify(t.name)}`);
+        tools.set(t.name, t);
+    }
+    const guardrails = new Map();
+    for (const g of Object.values(cls.guardrails ?? {})) {
+        if (guardrails.has(g.name))
+            fail(`two guardrails declare the name ${JSON.stringify(g.name)}`);
+        guardrails.set(g.name, g);
+    }
+    const taskTypes = new Map();
+    const accepts = cls.accepts ?? [];
+    if (accepts.length === 0)
+        fail("it accepts no task type: declare accepts = [taskAcceptance(...)]");
+    for (const a of accepts) {
+        if (taskTypes.has(a.taskType.name))
+            fail(`task type ${JSON.stringify(a.taskType.name)} is accepted twice`);
+        if (!Number.isInteger(a.maxIterations) || a.maxIterations < 1)
+            fail(`task type ${JSON.stringify(a.taskType.name)} needs a budget of at least one iteration`);
+        taskTypes.set(a.taskType.name, a.taskType);
+    }
+    if (!ok())
+        return undefined;
+    return Object.freeze({ kind: "autonomous-agent", id: cls.componentId, cls, tools, guardrails, taskTypes });
+}
 /** Collects a handler table by wire name, reporting a duplicate wire name or a kind the component cannot host. */
 export function collectHandlers(table, what, allowed, fail) {
     const out = new Map();
@@ -347,8 +388,8 @@ function registerEndpoint(cls, problems) {
     if (typeof cls.prefix !== "string" || !cls.prefix.startsWith("/") || (cls.prefix.length > 1 && cls.prefix.endsWith("/"))) {
         fail(`needs a static prefix starting with "/" and not ending with one, not ${JSON.stringify(cls.prefix)}`);
     }
-    if (!Object.values(AclValues).includes(cls.acl)) {
-        fail(`needs a static acl — Acl.allowAll, Acl.denyAll or Acl.authenticated. An unstated access rule is a decision nobody made`);
+    if (!isAcl(cls.acl)) {
+        fail(`needs a static acl — Acl.allowAll, Acl.denyAll, Acl.authenticated or Acl.allowCallers(...). An unstated access rule is a decision nobody made`);
     }
     const routes = new Map();
     const seen = new Map();
@@ -367,7 +408,7 @@ function registerEndpoint(cls, problems) {
             if (other)
                 fail(`routes ${other} and ${id} both declare ${key}`);
             seen.set(key, id);
-            if (r.acl !== undefined && !Object.values(AclValues).includes(r.acl))
+            if (r.acl !== undefined && !isAcl(r.acl))
                 fail(`routes.${id}: unknown acl ${JSON.stringify(r.acl)}`);
             routes.set(id, r);
         }

package/dist/spec.d.ts

@@ -1,7 +1,10 @@
-import { Endpoint_Acl, type Spec } from "./_proto/ankka/protocol/v1/discovery_pb.ts";
+import { type MessageInitShape } from "@bufbuild/protobuf";
+import { Endpoint_Acl, type CallerMatcherSchema, type Spec } from "./_proto/ankka/protocol/v1/discovery_pb.ts";
 import type { Registry } from "./service.ts";
-import { Acl } from "./routes.ts";
-export declare const PROTOCOL_VERSION = "1.0";
+import type { Acl } from "./routes.ts";
+export declare const PROTOCOL_VERSION = "1.2";
 export declare const SDK_NAME = "ankka-typescript";
 export declare function aclToProto(acl: Acl): Endpoint_Acl;
+/** The callers a CALLERS acl names, as discovery carries them; empty for every other rule. */
+export declare function callersToProto(acl: Acl): MessageInitShape<typeof CallerMatcherSchema>[];
 export declare function renderSpec(registry: Registry): Spec;

package/dist/spec.js

@@ -1,23 +1,42 @@
 // Renders the discovery Spec from the registry: what the sidecar hosts is exactly what is registered.
 import { create } from "@bufbuild/protobuf";
 import { Endpoint_Acl, SpecSchema } from "./_proto/ankka/protocol/v1/discovery_pb.js";
+import { resultSchemaJson } from "./autonomous.js";
 import { kindToProto } from "./kinds.js";
-import { Acl } from "./routes.js";
 import { toJsonSchema } from "./schema.js";
 import { isCodec } from "./codec.js";
 import { VERSION } from "./version.js";
-export const PROTOCOL_VERSION = "1.0";
+export const PROTOCOL_VERSION = "1.2";
 export const SDK_NAME = "ankka-typescript";
 export function aclToProto(acl) {
+    if (typeof acl === "object")
+        return Endpoint_Acl.CALLERS;
     switch (acl) {
-        case Acl.allowAll:
+        case "allow-all":
             return Endpoint_Acl.ALLOW_ALL;
-        case Acl.denyAll:
+        case "deny-all":
             return Endpoint_Acl.DENY_ALL;
-        case Acl.authenticated:
+        case "authenticated":
             return Endpoint_Acl.AUTHENTICATED;
     }
 }
+/** The callers a CALLERS acl names, as discovery carries them; empty for every other rule. */
+export function callersToProto(acl) {
+    if (typeof acl !== "object")
+        return [];
+    return acl.callers.map((m) => {
+        switch (m.kind) {
+            case "internet":
+                return { kind: { case: "internet", value: {} } };
+            case "anyInProject":
+                return { kind: { case: "anyInProject", value: {} } };
+            case "self":
+                return { kind: { case: "self", value: {} } };
+            case "service":
+                return { kind: { case: "service", value: m.project !== undefined ? { name: m.name, project: m.project } : { name: m.name } } };
+        }
+    });
+}
 function handlerInits(handlers) {
     return [...handlers.values()]
         .map((h) => ({ name: h.name, readOnly: h.readOnly, streaming: h.streaming }))
@@ -48,6 +67,8 @@ function settingsInit(s) {
 function componentInit(c) {
     const base = { kind: kindToProto(c.kind), id: c.id };
     switch (c.kind) {
+        case "autonomous-agent":
+            return autonomousInit(c);
         case "event-sourced":
             return { ...base, handlers: handlerInits(c.handlers), detail: { case: "eventSourced", value: { snapshotEvery: c.snapshotEvery } } };
         case "key-value":
@@ -82,19 +103,54 @@ function componentInit(c) {
             };
     }
 }
+function settingsOf(s) {
+    return {
+        ...(s.approachingBudgetAt !== undefined ? { approachingBudgetAt: s.approachingBudgetAt } : {}),
+        ...(s.repeatedFailureAt !== undefined ? { repeatedFailureAt: s.repeatedFailureAt } : {}),
+        ...(s.maxConsecutiveFailures !== undefined ? { maxConsecutiveFailures: s.maxConsecutiveFailures } : {}),
+        ...(s.dependencyStuckAfterMillis !== undefined ? { dependencyStuckAfterMillis: BigInt(s.dependencyStuckAfterMillis) } : {}),
+    };
+}
+function autonomousInit(c) {
+    const cls = c.cls;
+    return {
+        kind: kindToProto(c.kind),
+        id: c.id,
+        handlers: [],
+        detail: {
+            case: "autonomousAgent",
+            value: {
+                description: cls.description,
+                ...(cls.instructions !== undefined ? { instructions: cls.instructions } : {}),
+                ...(cls.model !== undefined ? { model: cls.model } : {}),
+                tools: [...c.tools.values()]
+                    .sort((a, b) => a.name.localeCompare(b.name))
+                    .map((t) => ({ name: t.name, description: t.description, inputSchemaJson: JSON.stringify(isCodec(t.input) ? { type: "object" } : toJsonSchema(t.input)) })),
+                guardrails: [...c.guardrails.keys()].sort(),
+                taskTypes: [...c.taskTypes.values()].map((t) => {
+                    const schema = resultSchemaJson(t);
+                    return { name: t.name, description: t.description, rules: t.rules.map((r) => r.name), ...(schema !== undefined ? { resultSchemaJson: schema } : {}) };
+                }),
+                accepts: cls.accepts.map((a) => ({ taskType: a.taskType.name, maxIterations: a.maxIterations })),
+                ...(cls.settings ? { settings: settingsOf(cls.settings) } : {}),
+            },
+        },
+    };
+}
 export function renderSpec(registry) {
     const components = [...registry.components.values()].sort((a, b) => a.id.localeCompare(b.id)).map(componentInit);
     const endpoints = [...registry.endpoints.values()].map((e) => ({
         id: e.id,
         prefix: e.prefix,
         acl: aclToProto(e.acl),
+        allowCallers: callersToProto(e.acl),
         routes: [...e.routes.entries()].map(([id, r]) => ({
             id,
             method: r.method,
             template: r.template,
             hasBody: r.body !== undefined,
             streaming: r.streaming,
-            ...(r.acl !== undefined ? { acl: aclToProto(r.acl) } : {}),
+            ...(r.acl !== undefined ? { acl: aclToProto(r.acl), allowCallers: callersToProto(r.acl) } : {}),
         })),
     }));
     return create(SpecSchema, {

package/dist/testkit/integration.js

@@ -223,7 +223,11 @@ export class AnkkaTestKit {
             ...this.#env,
         })
             .withExposedPorts(HTTP_PORT, CALLBACK_PORT)
-            .withWaitStrategy(tc.Wait.forHttp("/_ankka/health", HTTP_PORT).forStatusCode(200))
+            // Both ports, not only the health route: it answers as soon as HTTP is bound, which can be
+            // before the callback server listens, and Docker's port proxy accepts then resets a
+            // connection to a port nothing in the container listens on yet — so a handler's first call
+            // after a restart failed UNAVAILABLE. forListeningPorts checks from inside the container.
+            .withWaitStrategy(tc.Wait.forAll([tc.Wait.forHttp("/_ankka/health", HTTP_PORT).forStatusCode(200), tc.Wait.forListeningPorts()]))
             .withStartupTimeout(this.#readyTimeoutMs)
             .start();
         this.#sidecar = container;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.7.1";
+export declare const VERSION = "0.9.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 // Written by scripts/proto.ts from package.json; do not edit. 0.0.0 in the tree, the tag's version in a release.
-export const VERSION = "0.7.1";
+export const VERSION = "0.9.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ankka",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "description": "Build services on ankka in TypeScript: entities, views, workflows, agents and endpoints hosted by the ankka sidecar.",
   "license": "Apache-2.0",
   "type": "module",