@agentshouse/kit 0.1.0-alpha.4 → 0.1.0-alpha.40

package/src/blocks.js

@@ -1,8 +1,4 @@
-import {
-  ASSISTANT_BLOCKS_MAX,
-  ASSISTANT_TABLE_COLUMNS_MAX,
-  ASSISTANT_TEXT_MAX_BYTES,
-} from "./contract.js";
+import { ASSISTANT_TABLE_COLUMNS_MAX } from "./contract.js";
 
 const HEADING = /^(#{1,6})\s+(.+)$/;
 const BULLET = /^ {0,3}[-*+]\s+(.+)$/;
@@ -132,25 +128,5 @@ export function assistantBlocks(text) {
     index += 1;
   }
   endParagraph();
-  if (blocks.length === 0) return null;
-  if (blocks.length <= ASSISTANT_BLOCKS_MAX) return blocks;
-  const whole = text.trim();
-  return whole === "" ? null : [{ type: "paragraph", text: whole }];
-}
-
-export function blocksText(blocks) {
-  return blocks
-    .map((block) => {
-      if (block.type === "formula") return block.expression;
-      if (block.type === "list") return block.items.join("\n");
-      if (block.type === "table") {
-        return [block.headers, ...block.rows].map((row) => row.join("\t")).join("\n");
-      }
-      return block.text;
-    })
-    .join("\n\n");
-}
-
-export function withinAssistantBound(text) {
-  return Buffer.byteLength(text, "utf8") <= ASSISTANT_TEXT_MAX_BYTES;
+  return blocks.length === 0 ? null : blocks;
 }

package/src/bridge.js

@@ -16,9 +16,14 @@ import {
   TURN_OUTCOMES,
 } from "./contract.js";
 import { operationId } from "./operation.js";
+import { planSnapshot } from "./plan.js";
 import { houseFailed } from "./refusal.js";
 
-function bridgedFrame(request, operation) {
+function sequenced(value) {
+  return Number.isSafeInteger(value) && value > 0;
+}
+
+export function bridgedFrame(request, operation) {
   if (typeof request.method !== "string") return request;
   const params = typeof request.params === "object" && request.params !== null ? request.params : {};
   const declared = typeof params._meta === "object" && params._meta !== null ? params._meta : {};
@@ -50,6 +55,7 @@ export async function openBridge(options) {
     closed: false,
     questions: new Map(),
     interrupts: new Set(),
+    plan: null,
   };
   const connections = new Set();
   const clients = new Map();
@@ -201,38 +207,45 @@ export async function openBridge(options) {
       return;
     }
     if (frame.type === "draft") {
-      if (typeof frame.text === "string" && frame.text !== "") options.draft?.(frame.text);
+      if (typeof frame.text === "string" && frame.text !== "" && sequenced(frame.sequence)) {
+        options.draft?.({ text: frame.text, sequence: frame.sequence });
+      }
       return;
     }
-    if (
-      frame.type === "plan" &&
-      typeof frame.provider_turn === "string" &&
-      Array.isArray(frame.steps) &&
-      typeof frame.terminal === "boolean"
-    ) {
-      void options.plan?.({
-        provider_turn: frame.provider_turn,
-        steps: frame.steps,
-        terminal: frame.terminal,
-      });
+    if (frame.type === "plan") {
+      const snapshot = planSnapshot(frame);
+      if (snapshot === null || !sequenced(frame.sequence)) return;
+      state.plan = snapshot;
+      options.plan?.({ ...snapshot, sequence: frame.sequence });
       return;
     }
+    const carried = planSnapshot(frame.plan);
+    if (carried !== null) state.plan = carried;
     if (
       frame.type === "interrupt_applied" &&
       typeof frame.interrupt === "string" &&
       ["interrupted", "nothing_to_interrupt"].includes(frame.outcome) &&
       state.interrupts.has(frame.interrupt)
     ) {
-      const reported = options.interrupt?.(frame.interrupt, frame.outcome);
+      const reported = options.interrupt?.(
+        frame.interrupt,
+        frame.outcome,
+        frame.outcome === "interrupted" ? state.plan : null,
+      );
       if (reported === undefined) state.interrupts.delete(frame.interrupt);
       else void Promise.resolve(reported).finally(() => state.interrupts.delete(frame.interrupt));
       return;
     }
+    if (frame.type === "how_we_work") {
+      void options.howWeWork?.();
+      return;
+    }
     if (frame.type === "turn_ended") {
       state.stop = {
         providerContinuation: frame.provider_continuation === true,
         providerSessionId: typeof frame.provider_session_id === "string" && frame.provider_session_id.length > 0 && frame.provider_session_id.length <= 512 ? frame.provider_session_id : null,
         stopOutcome: TURN_OUTCOMES.includes(frame.stop_outcome) ? frame.stop_outcome : null,
+        plan: carried,
       };
       return;
     }
@@ -432,6 +445,7 @@ export async function openBridge(options) {
         .filter((interaction) => interaction !== null),
     assistant: () => [...state.assistant],
     stop: () => state.stop,
+    plan: () => state.plan,
     failure: () => state.failure,
     stopRecovery: () => lifetime.abort(),
     async close() {

package/src/bytes.js

@@ -31,6 +31,11 @@ async function downloadBody(response, signal) {
   return Buffer.concat(chunks, size);
 }
 
+function framedBody(request) {
+  if (request.method !== "POST" || !Buffer.isBuffer(request.body)) throw new KitRefusal("kit_byte_body_invalid");
+  return Buffer.concat([Buffer.from(`${request.operation}\n`, "utf8"), request.body]);
+}
+
 export async function transferBytes(request, dependencies = {}) {
   if (request.method !== "GET" && request.method !== "POST") {
     throw new KitRefusal("kit_byte_method_invalid", request.method);
@@ -38,26 +43,32 @@ export async function transferBytes(request, dependencies = {}) {
   if (typeof request.url !== "string" || request.url.length === 0) {
     throw new KitRefusal("kit_byte_url_invalid");
   }
-  if (typeof request.operation !== "string" || request.operation.length === 0) {
+  if (request.method === "POST" && (typeof request.operation !== "string" || request.operation.length === 0)) {
     throw new KitRefusal("kit_byte_operation_invalid");
   }
+  const framed = request.framed === true;
+  const body = framed ? framedBody(request) : request.body;
   if (request.method === "POST") {
-    if (!Buffer.isBuffer(request.body)) throw new KitRefusal("kit_byte_body_invalid");
-    if (request.body.length > BYTE_GRANT_POST_BYTES_MAX) {
+    if (!Buffer.isBuffer(body)) throw new KitRefusal("kit_byte_body_invalid");
+    if (body.length > BYTE_GRANT_POST_BYTES_MAX) {
       throw new KitRefusal("original_bytes_exceeded");
     }
   }
   const fetcher = dependencies.fetch ?? fetch;
-  const headers = {
-    [BYTE_GRANT_OPERATION_HEADER]: request.operation,
-  };
-  if (request.method === "POST") headers["content-type"] = "application/octet-stream";
+  const headers = framed
+    ? { "content-type": "text/plain; charset=utf-8" }
+    : request.method === "POST"
+      ? {
+          [BYTE_GRANT_OPERATION_HEADER]: request.operation,
+          "content-type": "application/octet-stream",
+        }
+      : {};
   let response;
   try {
     response = await fetcher(request.url, {
       method: request.method,
       headers,
-      body: request.method === "POST" ? request.body : undefined,
+      body: request.method === "POST" ? body : undefined,
       redirect: "manual",
       signal: request.signal,
     });

package/src/configuration.js

@@ -7,18 +7,10 @@ import {
   MIGRATOR_TIMEOUT_MS,
 } from "./contract.js";
 import { declarationReader } from "./declaration.js";
-import { GOOGLE_DRIVE_ID } from "./google/id.js";
 import { KitRefusal } from "./refusal.js";
 
-const PRESETS = new Set(["custom", "google"]);
 const AGENT_CLIENTS = new Set(["claude-code"]);
-const GOOGLE_CURATED_SERVICES = new Set(["gmail", "calendar", "drive"]);
 const ENVIRONMENT_VALUE_MAX = 4096;
-const GOOGLE_API_HOST = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*\.googleapis\.com$/;
-const GOOGLE_API_PATH = /^\/[A-Za-z0-9._~!$&'()*+,;=:@%/-]+$/;
-const GOOGLE_API_SCOPE = /^https:\/\/www\.googleapis\.com\/auth\/[A-Za-z0-9._-]+$/;
-const EXTRACTION_PATH = /^(?:[A-Za-z_][A-Za-z0-9_-]*|\d+)(?:\.(?:[A-Za-z_][A-Za-z0-9_-]*|\d+))*$/;
-const QUERY_NAME = /^[A-Za-z][A-Za-z0-9_.-]{0,127}$/;
 
 const { refuse, plain, closed, text, positiveCount, filled } = declarationReader(
   "kit_configuration_invalid",
@@ -116,225 +108,33 @@ function backfillOf(value, declaration) {
   return { kind: named[0], bound: positiveCount(backfill[named[0]], declaration) };
 }
 
-function textList(value, declaration) {
-  return filled(value, declaration).map((entry, position) =>
-    text(entry, `${declaration}[${position}]`, 512),
-  );
-}
-
-function textArray(value, declaration) {
-  if (!Array.isArray(value)) refuse(declaration);
-  return value.map((entry, position) => text(entry, `${declaration}[${position}]`, 512));
-}
-
-function googleSelectionOf(value, declaration, service) {
-  if (service === "gmail") {
-    const selection = closed(value, ["labels"], declaration);
-    return { labels: textList(selection.labels, `${declaration}.labels`) };
-  }
-  if (service === "calendar") {
-    const selection = closed(value, ["calendars"], declaration);
-    return { calendars: textList(selection.calendars, `${declaration}.calendars`) };
-  }
-  if (service === "drive") {
-    const selection = closed(value, ["files", "folders"], declaration);
-    const files =
-      selection.files === undefined ? [] : textArray(selection.files, `${declaration}.files`);
-    const folders =
-      selection.folders === undefined ? [] : textArray(selection.folders, `${declaration}.folders`);
-    if (files.length + folders.length === 0) refuse(declaration);
-    files.forEach((id, position) => {
-      if (!GOOGLE_DRIVE_ID.test(id)) refuse(`${declaration}.files[${position}]`);
-    });
-    folders.forEach((id, position) => {
-      if (!GOOGLE_DRIVE_ID.test(id)) refuse(`${declaration}.folders[${position}]`);
-    });
-    return { files, folders };
-  }
-  refuse(declaration);
-}
-
-function extractionPath(value, declaration) {
-  const path = text(value, declaration, 512);
-  if (!EXTRACTION_PATH.test(path)) refuse(declaration);
-  return path;
-}
-
-function queryOf(value, declaration) {
-  const query = plain(value, declaration);
-  const parsed = {};
-  for (const [name, entry] of Object.entries(query)) {
-    if (!QUERY_NAME.test(name) || typeof entry !== "string" || entry.length > 2048) {
-      refuse(`${declaration}.${name}`);
-    }
-    parsed[name] = entry;
-  }
-  return parsed;
-}
-
-function declaredServiceOf(value, declaration) {
-  const declared = closed(
-    value,
-    ["host", "path", "query", "page_size", "page_token", "items", "fields", "scopes"],
-    declaration,
-  );
-  const host = text(declared.host, `${declaration}.host`, 253);
-  if (!GOOGLE_API_HOST.test(host)) refuse(`${declaration}.host`);
-  const path = text(declared.path, `${declaration}.path`, 2048);
-  if (!GOOGLE_API_PATH.test(path) || path.includes("..") || path.includes("//")) {
-    refuse(`${declaration}.path`);
-  }
-  const tokens = closed(
-    declared.page_token,
-    ["request", "response", "checkpoint_request", "checkpoint_response"],
-    `${declaration}.page_token`,
-  );
-  const pageToken = {
-    request: text(tokens.request, `${declaration}.page_token.request`, 128),
-    response: extractionPath(tokens.response, `${declaration}.page_token.response`),
-    checkpointRequest: text(
-      tokens.checkpoint_request,
-      `${declaration}.page_token.checkpoint_request`,
-      128,
-    ),
-    checkpointResponse: extractionPath(
-      tokens.checkpoint_response,
-      `${declaration}.page_token.checkpoint_response`,
-    ),
-  };
-  if (
-    !QUERY_NAME.test(pageToken.request) ||
-    !QUERY_NAME.test(pageToken.checkpointRequest) ||
-    pageToken.request === pageToken.checkpointRequest
-  ) {
-    refuse(`${declaration}.page_token`);
-  }
-  const fields = closed(
-    declared.fields,
-    [
-      "native_id",
-      "native_version",
-      "provider_modified_at",
-      "observed_at",
-      "body",
-      "container",
-      "author",
-      "url",
-    ],
-    `${declaration}.fields`,
-  );
-  const pageSize = text(declared.page_size, `${declaration}.page_size`, 128);
-  if (!QUERY_NAME.test(pageSize)) refuse(`${declaration}.page_size`);
-  const scopes = textList(declared.scopes, `${declaration}.scopes`).map((scope, position) => {
-    if (!GOOGLE_API_SCOPE.test(scope)) refuse(`${declaration}.scopes[${position}]`);
-    return scope;
-  });
-  return {
-    host,
-    path,
-    query: queryOf(declared.query, `${declaration}.query`),
-    pageSize,
-    scopes: [...new Set(scopes)],
-    pageToken,
-    items: extractionPath(declared.items, `${declaration}.items`),
-    fields: {
-      nativeId: extractionPath(fields.native_id, `${declaration}.fields.native_id`),
-      nativeVersion:
-        fields.native_version === undefined
-          ? null
-          : extractionPath(fields.native_version, `${declaration}.fields.native_version`),
-      providerModifiedAt:
-        fields.provider_modified_at === undefined
-          ? null
-          : extractionPath(
-              fields.provider_modified_at,
-              `${declaration}.fields.provider_modified_at`,
-            ),
-      observedAt: extractionPath(fields.observed_at, `${declaration}.fields.observed_at`),
-      body: textList(fields.body, `${declaration}.fields.body`).map((path, position) =>
-        extractionPath(path, `${declaration}.fields.body[${position}]`),
-      ),
-      container: extractionPath(fields.container, `${declaration}.fields.container`),
-      author:
-        fields.author === undefined
-          ? null
-          : extractionPath(fields.author, `${declaration}.fields.author`),
-      url:
-        fields.url === undefined ? null : extractionPath(fields.url, `${declaration}.fields.url`),
-    },
-  };
-}
-
-function serviceOf(value, declaration, preset) {
+function serviceOf(value, declaration) {
   const service = closed(
     value,
-    ["service", "source_ref", "rooms", "backfill", "connector", "selection", "declaration"],
+    ["service", "source_ref", "rooms", "backfill", "connector"],
     declaration,
   );
-  const name = declaredId(service.service, `${declaration}.service`);
-  if (preset === "custom" && service.connector === undefined) refuse(`${declaration}.connector`);
-  if (preset === "custom" && service.selection !== undefined) refuse(`${declaration}.selection`);
-  if (preset === "custom" && service.declaration !== undefined) refuse(`${declaration}.declaration`);
-  if (preset === "google" && service.connector !== undefined) refuse(`${declaration}.connector`);
-  if (preset === "google" && GOOGLE_CURATED_SERVICES.has(name) && service.declaration !== undefined) {
-    refuse(`${declaration}.declaration`);
-  }
-  if (preset === "google" && !GOOGLE_CURATED_SERVICES.has(name)) {
-    if (service.selection !== undefined) refuse(`${declaration}.selection`);
-    if (service.declaration === undefined) refuse(`${declaration}.declaration`);
-  }
   return {
-    service: name,
+    service: declaredId(service.service, `${declaration}.service`),
     sourceRef: text(service.source_ref, `${declaration}.source_ref`, 512),
     rooms: filled(service.rooms, `${declaration}.rooms`).map((room, position) =>
       text(room, `${declaration}.rooms[${position}]`, 512),
     ),
     backfill: backfillOf(service.backfill, `${declaration}.backfill`),
-    selection:
-      preset === "google" && GOOGLE_CURATED_SERVICES.has(name)
-        ? googleSelectionOf(service.selection, `${declaration}.selection`, name)
-        : null,
-    connector: preset === "custom" ? connectorOf(service.connector, `${declaration}.connector`) : null,
-    declaration:
-      preset === "google" && !GOOGLE_CURATED_SERVICES.has(name)
-        ? declaredServiceOf(service.declaration, `${declaration}.declaration`)
-        : null,
+    connector: connectorOf(service.connector, `${declaration}.connector`),
   };
 }
 
 function instanceOf(value, declaration) {
-  const instance = closed(value, ["id", "preset", "services", "scopes"], declaration);
-  const preset = declaredId(instance.preset, `${declaration}.preset`);
-  if (!PRESETS.has(preset)) refuse(`${declaration}.preset`);
-  if (preset !== "google" && instance.scopes !== undefined) refuse(`${declaration}.scopes`);
-  const scopes =
-    instance.scopes === undefined
-      ? []
-      : textList(instance.scopes, `${declaration}.scopes`).map((scope, position) => {
-          if (!GOOGLE_API_SCOPE.test(scope)) refuse(`${declaration}.scopes[${position}]`);
-          return scope;
-        });
+  const instance = closed(value, ["id", "preset", "services"], declaration);
   const services = filled(instance.services, `${declaration}.services`).map((service, position) =>
-    serviceOf(service, `${declaration}.services[${position}]`, preset),
+    serviceOf(service, `${declaration}.services[${position}]`),
   );
   services.forEach((service, position) => {
     const first = services.findIndex((candidate) => candidate.service === service.service);
     if (first !== position) refuse(`${declaration}.services[${position}].service`);
   });
-  services.forEach((service, position) => {
-    if (
-      service.declaration !== null &&
-      service.declaration.scopes.some((scope) => !scopes.includes(scope))
-    ) {
-      refuse(`${declaration}.services[${position}].declaration.scopes`);
-    }
-  });
-  return {
-    id: declaredId(instance.id, `${declaration}.id`),
-    preset,
-    services,
-    ...(preset === "google" ? { scopes: [...new Set(scopes)] } : {}),
-  };
+  return { id: declaredId(instance.id, `${declaration}.id`), preset: instance.preset, services };
 }
 
 function absolutePath(value, declaration) {
@@ -360,12 +160,11 @@ function maximaOf(value, declaration) {
 
 function hostOf(value, declaration) {
   if (value === null) return null;
-  const host = closed(value, ["workspace", "maxima", "image"], declaration);
+  const host = closed(value, ["workspace", "maxima"], declaration);
   if (host.maxima === undefined) refuse(`${declaration}.maxima`);
   return {
     workspace: absolutePath(host.workspace, `${declaration}.workspace`),
     maxima: maximaOf(host.maxima, `${declaration}.maxima`),
-    image: host.image === undefined || host.image === null ? null : text(host.image, `${declaration}.image`, 255),
   };
 }
 
@@ -388,6 +187,7 @@ export function parseConfiguration(document) {
       "migrators",
       "clients",
       "host",
+      "skills",
     ],
     "configuration",
   );
@@ -397,10 +197,12 @@ export function parseConfiguration(document) {
   if (!EXECUTION_AUTHORITIES.includes(declared.execution_authority)) {
     refuse("execution_authority");
   }
+  const skills = declared.skills === undefined ? true : declared.skills;
+  if (typeof skills !== "boolean") refuse("skills");
   if (!Array.isArray(declared.instances)) refuse("instances");
   if (!Array.isArray(declared.migrators)) refuse("migrators");
-  const instances = declared.instances.map((instance, position) =>
-    instanceOf(instance, `instances[${position}]`),
+  const instances = declared.instances.flatMap((instance, position) =>
+    instance?.preset === "custom" ? [instanceOf(instance, `instances[${position}]`)] : [],
   );
   instances.forEach((instance, position) => {
     const first = instances.findIndex((candidate) => candidate.id === instance.id);
@@ -428,6 +230,7 @@ export function parseConfiguration(document) {
     migrators,
     clients,
     host: hostOf(declared.host, "host"),
+    skills,
   };
 }
 

package/src/connector-login.js

@@ -1,91 +1,10 @@
 import { readConfiguration, sourceInstance } from "./configuration.js";
 import { authorizeCustom, customAuthorizationStatus } from "./custom/authorization.js";
-import { googleAuthorization, authorizeGoogle, GOOGLE_SCOPES } from "./google/oauth.js";
-import { KitRefusal } from "./refusal.js";
 
-function googleServiceScopes(service) {
-  const curated = GOOGLE_SCOPES[service.service];
-  return curated === undefined ? service.declaration.scopes : [curated];
-}
-
-function googleServiceAuthorized(authorization, scopes) {
-  return authorization.grants.some((grant) =>
-    scopes.every((scope) => grant.scopes.includes(scope)),
-  );
-}
-
-function googleConsent(service, context) {
-  return async ({ url }) => {
-    const collected = await context.present(
-      {
-        steps: [
-          { kind: "visit", label: `Sign in to Google and allow access for ${service.service}`, url },
-          {
-            kind: "collect",
-            label: "The address your browser ended on",
-            name: "address",
-            description:
-              "After you allow access, Google sends your browser to a 127.0.0.1 address that does not open. Copy that whole address from the address bar and paste it here.",
-          },
-        ],
-      },
-      context.signal,
-    );
-    return collected.address;
-  };
-}
-
-const CONNECTOR_LOGINS = {
-  custom: {
-    status: customAuthorizationStatus,
-    login: authorizeCustom,
-  },
-  google: {
-    status: async (instance, context) => {
-      const authorization = await googleAuthorization(context.directory, instance.id);
-      if (authorization === null) return false;
-      return instance.services.every((service) =>
-        googleServiceAuthorized(authorization, googleServiceScopes(service)),
-      );
-    },
-    guided: async (instance, context) => {
-      for (const service of instance.services) {
-        try {
-          await authorizeGoogle(
-            {
-              directory: context.directory,
-              instance: instance.id,
-              client: context.dependencies.googleOAuthClient(),
-              scopes: googleServiceScopes(service),
-              approve: googleConsent(service, context),
-            },
-            context.dependencies.googleDependencies ?? {},
-          );
-        } catch (error) {
-          if (context.signal.aborted) return "cancelled";
-          if (error instanceof KitRefusal && error.code === "google_authorization_declined") {
-            return "cancelled";
-          }
-          return "failed";
-        }
-      }
-      return "ready";
-    },
-  },
-};
-
-export function connectorLogin(instance, dependencies = {}) {
-  return { ...CONNECTOR_LOGINS, ...(dependencies.connectorLogins ?? {}) }[instance.preset];
-}
-
-export async function signInConnector(options, dependencies = {}) {
+export async function signInConnector(options) {
   const configuration = await readConfiguration(options.configuration);
   const instance = sourceInstance(configuration, options.instance);
-  const gateway = connectorLogin(instance, dependencies);
-  if (gateway.login === undefined) {
-    throw new KitRefusal("kit_connector_login_guided", `${instance.id} signs in through House setup`);
-  }
   const context = { directory: options.directory, signal: options.signal };
-  if (await gateway.status(instance, context)) return "skipped";
-  return (await gateway.login(instance, context)) ? "ready" : "needs_attention";
+  if (await customAuthorizationStatus(instance, context)) return "skipped";
+  return (await authorizeCustom(instance, context)) ? "ready" : "needs_attention";
 }