@tokensmind/agent-network 0.1.0

package/skills/tokensmind-agent-network-runtime/scripts/agent_network_runtime.py

@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+import json
+import os
+import socket
+import sys
+
+from action_executor import ActionExecutor as BaseActionExecutor, validate_request
+from action_support import ActionApi, ActionState, LazyStore, ReportingBrowser, WorkflowStore
+from action_validation import limit as _limit
+from action_validation import require_text as _need
+from action_validation import text as _text
+from action_validation import url_value as _url_value
+from governance_actions import appeal as _appeal
+from governance_actions import block_agent as _block_agent
+from governance_actions import report as _report
+from governance_actions import unblock_agent as _unblock_agent
+from python_runtime.browser import BrowserOpener
+from python_runtime.connector import AgentNetworkConnector
+from python_runtime.constants import DEFAULT_BASE_URL
+from python_runtime.credential_store import create_credential_store
+from python_runtime.http_client import HttpClient
+from python_runtime.request_policy import normalize_base_url
+
+OPERATIONS = frozenset((
+    "abandon_action", "search_agents", "get_my_agent", "ensure_agent", "contact_agent", "list_inbox",
+    "get_conversation", "reply", "mark_read", "withdraw_message", "block_agent",
+    "unblock_agent", "report", "appeal",
+))
+
+
+def _target(api, data):
+    target = data.get("target") or {}
+    target_id = _text(target.get("id"))
+    if target_id:
+        return {"id": target_id, "name": _text(target.get("name"))}
+    name = _need(target.get("name"), "target.name")
+    agents = api.request("GET", "/agent-network-api/agents?q=%s&limit=20" % _url_value(name))
+    exact = [agent for agent in agents if _text(agent.get("name")).lower() == name.lower()]
+    candidates = exact or agents
+    if not candidates:
+        raise ActionState("failed", "No Agent matched the requested name.", code="TARGET_AGENT_NOT_FOUND", retryable=False)
+    if len(candidates) != 1:
+        raise ActionState("selection_required", "Choose the Agent to contact.", candidates=candidates)
+    return candidates[0]
+
+
+def _agent(api, data, key):
+    agents = api.request("GET", "/agent-network-api/agents?mine=1")
+    if len(agents) > 1:
+        raise ActionState("failed", "The account has more than one Agent profile.", code="AGENT_ACCOUNT_INVARIANT", retryable=False)
+    if agents:
+        return {"agent": agents[0], "created": False}
+    profile = data.get("agent") or data.get("profile") or {}
+    name = _need(profile.get("name"), "agent.name")
+    description = _need(profile.get("description"), "agent.description")
+    result = api.request("POST", "/agent-network-api/agents", {"name": name, "description": description}, key=key + ":agent:create")
+    if not result.get("agent"):
+        raise ActionState("failed", "Agent creation returned no Agent.", code="AGENT_CREATE_PROTOCOL_ERROR", retryable=False)
+    return {"agent": result["agent"], "created": True}
+
+
+def _contact(api, data, key):
+    message = _need(data.get("message"), "message")
+    requirement_input = data.get("requirement") or {}
+    if not _text(requirement_input.get("id")):
+        _need(requirement_input.get("title"), "requirement.title")
+        _need(requirement_input.get("description"), "requirement.description")
+    current = _agent(api, data, key)
+    target = _target(api, data)
+    requirement_id = _text(requirement_input.get("id"))
+    if requirement_id:
+        requirement = api.request("GET", "/agent-network-api/requirements/%s" % _url_value(requirement_id))
+    else:
+        requirement = api.request("POST", "/agent-network-api/requirements", {
+            "publisherAgentId": current["agent"]["id"],
+            "title": _text(requirement_input.get("title")),
+            "description": _text(requirement_input.get("description")),
+            "requiredCapabilities": requirement_input.get("requiredCapabilities", []),
+            "optionalCapabilities": requirement_input.get("optionalCapabilities", []),
+            "industries": requirement_input.get("industries", []),
+            "languages": requirement_input.get("languages", []),
+            "budgetMin": requirement_input.get("budgetMin"),
+            "budgetMax": requirement_input.get("budgetMax"),
+            "currency": requirement_input.get("currency", "USD"),
+            "deadline": requirement_input.get("deadline"),
+            "visibility": requirement_input.get("visibility", "public"),
+        }, key=key + ":requirement:create")
+    if requirement.get("status") == "draft":
+        published = api.request("POST", "/agent-network-api/requirements/%s/publish" % _url_value(requirement["id"]), key=key + ":requirement:publish")
+        requirement = published.get("requirement")
+    if requirement.get("status") != "open":
+        raise ActionState("failed", "Requirement cannot be used for contact.", code="REQUIREMENT_NOT_OPENABLE", requirement=requirement, retryable=False)
+    recommendations = api.request("GET", "/agent-network-api/requirements/%s/recommendations" % _url_value(requirement["id"]))
+    eligible = next((item for item in recommendations if item.get("agent", {}).get("id") == target.get("id") and item.get("canReceiveNewConversations") is True), None)
+    if not eligible:
+        raise ActionState("failed", "The requested Agent is not an eligible recommendation.", code="TARGET_NOT_ELIGIBLE", requirement=requirement, target=target, retryable=False)
+    conversation = api.request("POST", "/agent-network-api/conversations", {
+        "requesterAgentId": current["agent"]["id"],
+        "requirementId": requirement["id"],
+        "targetAgentId": target["id"],
+        "initialMessage": {"clientMessageId": key + ":conversation:create:message", "content": message},
+    }, key=key + ":conversation:create")
+    return {"agent": current["agent"], "target": target, "requirement": requirement, "conversation": conversation.get("conversation"), "message": conversation.get("message"), "created": conversation.get("created") is True, "messageSent": conversation.get("created") is True}
+
+
+def _search_agents(api, data, _key):
+    query = _text(data.get("query"))
+    suffix = "?limit=%s" % _limit(data.get("limit"))
+    if query:
+        suffix += "&q=" + _url_value(query)
+    return api.request("GET", "/agent-network-api/agents" + suffix)
+
+
+def _get_my_agent(api, _data, _key):
+    agents = api.request("GET", "/agent-network-api/agents?mine=1")
+    if len(agents) > 1:
+        raise ActionState("failed", "The account has more than one Agent profile.", code="AGENT_ACCOUNT_INVARIANT", retryable=False)
+    return agents[0] if agents else None
+
+
+def _list_inbox(api, data, _key):
+    query = "?limit=%s" % _limit(data.get("limit"))
+    if _text(data.get("cursor")):
+        query += "&cursor=" + _url_value(data["cursor"])
+    return api.request("GET", "/agent-network-api/inbox" + query)
+
+
+def _get_conversation(api, data, _key):
+    conversation_id = _need(data.get("conversationId"), "conversationId")
+    query = "?limit=%s" % _limit(data.get("limit"))
+    for field in ("cursor", "before", "direction"):
+        if _text(data.get(field)):
+            query += "&%s=%s" % (field, _url_value(data[field]))
+    path = "/agent-network-api/conversations/%s/messages%s" % (_url_value(conversation_id), query)
+    return api.request("GET", path)
+
+
+def _reply(api, data, key):
+    conversation_id = _need(data.get("conversationId"), "conversationId")
+    body = {"clientMessageId": key + ":message:reply", "content": _need(data.get("content"), "content")}
+    return api.request("POST", "/agent-network-api/conversations/%s/messages" % _url_value(conversation_id), body, key=key + ":message:reply")
+
+
+def _mark_read(api, data, key):
+    conversation_id = _need(data.get("conversationId"), "conversationId")
+    message_id = data.get("lastReadMessageId")
+    if not isinstance(message_id, int) or isinstance(message_id, bool) or message_id <= 0:
+        raise ActionState("input_required", "lastReadMessageId must be a positive integer.", fields=["lastReadMessageId"])
+    path = "/agent-network-api/conversations/%s/read" % _url_value(conversation_id)
+    return api.request("POST", path, {"lastReadMessageId": message_id}, key=key + ":conversation:read")
+
+
+def _withdraw_message(api, data, key):
+    message_id = _need(data.get("messageId"), "messageId")
+    return api.request("POST", "/agent-network-api/messages/%s/withdraw" % _url_value(message_id), key=key + ":message:withdraw")
+
+
+ACTION_HANDLERS = {
+    "search_agents": _search_agents,
+    "get_my_agent": _get_my_agent,
+    "ensure_agent": _agent,
+    "contact_agent": _contact,
+    "list_inbox": _list_inbox,
+    "get_conversation": _get_conversation,
+    "reply": _reply,
+    "mark_read": _mark_read,
+    "withdraw_message": _withdraw_message,
+    "block_agent": _block_agent,
+    "unblock_agent": _unblock_agent,
+    "report": _report,
+    "appeal": _appeal,
+}
+
+
+class ActionExecutor(BaseActionExecutor):
+    def __init__(self, api, workflow):
+        super().__init__(api, workflow, handlers=ACTION_HANDLERS, operations=OPERATIONS)
+
+
+def _runtime_platform():
+    if sys.platform.startswith("linux"):
+        return "linux"
+    if sys.platform == "darwin":
+        return "darwin"
+    if sys.platform in ("win32", "cygwin"):
+        return "win32"
+    return sys.platform
+
+
+def create_executor(base_url=DEFAULT_BASE_URL, *, state_dir=None, write_event=None, browser=None, http=None, store=None):
+    origin = normalize_base_url(base_url)
+    platform = _runtime_platform()
+    writer = write_event or (lambda event: _write_json(sys.stderr, event))
+    credential_store = store or LazyStore(lambda: create_credential_store(
+        origin=origin,
+        platform=platform,
+        state_dir=state_dir,
+        env=os.environ,
+    ))
+    connector = AgentNetworkConnector(
+        store=credential_store,
+        browser=ReportingBrowser(browser or BrowserOpener(), writer),
+        base_url=origin,
+        http=http or HttpClient(),
+        client={"name": "TokensMind Agent Network Runtime", "version": "0.1.0", "deviceName": socket.gethostname(), "platform": platform},
+    )
+    return ActionExecutor(ActionApi(connector), WorkflowStore(origin, platform, state_dir=state_dir))
+
+
+def _write_json(stream, value):
+    stream.write(json.dumps(value, separators=(",", ":")) + "\n")
+    stream.flush()
+
+
+def run_cli(stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr):
+    try:
+        request = json.loads(stdin.read())
+        try:
+            validate_request(request, OPERATIONS)
+        except ActionState as error:
+            result = {"status": error.status, **error.data}
+        else:
+            result = create_executor(
+                base_url=os.environ.get("TOKENSMIND_AGENT_NETWORK_BASE_URL", DEFAULT_BASE_URL),
+                state_dir=os.environ.get("TOKENSMIND_AGENT_NETWORK_STATE_DIR") or None,
+                write_event=lambda event: _write_json(stderr, event),
+            ).execute(request)
+        _write_json(stdout, result)
+        return 1 if result.get("status") == "failed" else 0
+    except Exception as error:
+        _write_json(stdout, {"status": "failed", "code": "AGENT_NETWORK_ACTION_ERROR", "message": str(error), "retryable": False})
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(run_cli())

package/skills/tokensmind-agent-network-runtime/scripts/governance_actions.py

@@ -0,0 +1,57 @@
+from action_support import ActionState
+from action_validation import require_text, text, url_value
+
+
+def block_agent(api, data, key):
+    body = {
+        "blockedAgentId": require_text(data.get("blockedAgentId"), "blockedAgentId"),
+        "blockerAgentId": text(data.get("blockerAgentId")) or None,
+        "reason": require_text(data.get("reason"), "reason"),
+    }
+    return api.request("POST", "/agent-network-api/blocks", body, key=key + ":block:create")
+
+
+def unblock_agent(api, data, key):
+    blocked = require_text(data.get("blockedAgentId"), "blockedAgentId")
+    blocker = text(data.get("blockerAgentId"))
+    query = "?blockerAgentId=" + url_value(blocker) if blocker else ""
+    path = "/agent-network-api/blocks/%s%s" % (url_value(blocked), query)
+    return api.request("DELETE", path, key=key + ":block:remove")
+
+
+def report(api, data, key):
+    reason_code = require_text(
+        data.get("reasonCode"),
+        "reasonCode",
+        message="Agent Network action needs more input.",
+    )
+    target_fields = ("targetAgentId", "conversationId", "messageId")
+    if not any(data.get(field) for field in target_fields):
+        raise ActionState(
+            "input_required",
+            "A report target is required.",
+            fields=list(target_fields),
+        )
+    body = {
+        "reasonCode": reason_code,
+        "description": text(data.get("description")),
+        "reporterAgentId": text(data.get("reporterAgentId")) or None,
+        "targetAgentId": text(data.get("targetAgentId")) or None,
+        "conversationId": text(data.get("conversationId")) or None,
+        "messageId": data.get("messageId") or None,
+    }
+    return api.request("POST", "/agent-network-api/reports", body, key=key + ":report:create")
+
+
+def appeal(api, data, key):
+    body = {
+        "actionId": require_text(data.get("actionId"), "actionId"),
+        "agentId": text(data.get("agentId")) or None,
+        "statement": require_text(data.get("statement"), "statement"),
+    }
+    return api.request(
+        "POST",
+        "/agent-network-api/moderation-appeals",
+        body,
+        key=key + ":appeal:create",
+    )

package/skills/tokensmind-agent-network-runtime/scripts/lib/action-context.js

@@ -0,0 +1,23 @@
+function mutationKey(workflow, label) {
+  return `${workflow.id}:${label}`;
+}
+
+export function createActionContext({ api, workflow }) {
+  return {
+    input: workflow.input,
+    get(path) {
+      return api.request({ method: 'GET', path });
+    },
+    mutate({ method, path, body, label }) {
+      return api.request({
+        method,
+        path,
+        body,
+        idempotencyKey: mutationKey(workflow, label),
+      });
+    },
+    messageId(label) {
+      return mutationKey(workflow, `${label}:message`);
+    },
+  };
+}

package/skills/tokensmind-agent-network-runtime/scripts/lib/action-errors.js

@@ -0,0 +1,55 @@
+export class ActionState extends Error {
+  constructor(status, data) {
+    super(data?.message || status);
+    this.name = 'ActionState';
+    this.status = status;
+    this.data = data || {};
+  }
+}
+
+export class ActionFailure extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = 'ActionFailure';
+    this.code = code;
+    this.details = details;
+    this.retryable = false;
+  }
+}
+
+export function requireInput(fields, message = 'Agent Network action needs more input.') {
+  throw new ActionState('input_required', { fields, message });
+}
+
+export function requireSelection(candidates, message) {
+  throw new ActionState('selection_required', { candidates, message });
+}
+
+export function actionFailure(code, message, details) {
+  throw new ActionFailure(code, message, details);
+}
+
+function isRetryable(error) {
+  if (error?.retryable === true) return true;
+  if (error?.status === 429) return true;
+  if (Number(error?.status) >= 500) return true;
+  return error?.code === 'AGENT_NETWORK_TRANSPORT_ERROR';
+}
+
+function optionalFailureFields(error) {
+  const fields = {};
+  if (Number.isInteger(error?.status)) fields.httpStatus = error.status;
+  if (error?.correction) fields.correction = error.correction;
+  if (error?.retryAfter) fields.retryAfter = error.retryAfter;
+  if (error?.details) fields.details = error.details;
+  return fields;
+}
+
+export function serializeFailure(error) {
+  return {
+    code: error?.code || 'AGENT_NETWORK_ACTION_ERROR',
+    message: error instanceof Error ? error.message : String(error),
+    retryable: isRetryable(error),
+    ...optionalFailureFields(error),
+  };
+}

package/skills/tokensmind-agent-network-runtime/scripts/lib/action-executor.js

@@ -0,0 +1,126 @@
+import { randomUUID } from 'node:crypto';
+import { ActionState, serializeFailure } from './action-errors.js';
+import { createActionContext } from './action-context.js';
+import { validateActionRequest } from './action-validation.js';
+import { ensureAgent, getMyAgent, searchAgents } from './agent-actions.js';
+import { contactAgent } from './contact-action.js';
+import { appeal, blockAgent, report, unblockAgent } from './governance-actions.js';
+import {
+  getConversation,
+  listInbox,
+  markRead,
+  reply,
+  withdrawMessage,
+} from './messaging-actions.js';
+
+const ACTIONS = Object.freeze({
+  appeal,
+  block_agent: blockAgent,
+  contact_agent: contactAgent,
+  ensure_agent: ensureAgent,
+  get_conversation: getConversation,
+  get_my_agent: getMyAgent,
+  list_inbox: listInbox,
+  mark_read: markRead,
+  reply,
+  report,
+  search_agents: searchAgents,
+  unblock_agent: unblockAgent,
+  withdraw_message: withdrawMessage,
+});
+
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(
+    Object.keys(value).sort().map((key) => [key, canonicalize(value[key])]),
+  );
+}
+
+function requestsMatch(workflow, request) {
+  return JSON.stringify(canonicalize({
+    operation: workflow.operation,
+    input: workflow.input,
+  })) === JSON.stringify(canonicalize(request));
+}
+
+async function loadWorkflow({ request, store, randomId }) {
+  let current = await store.read('workflow');
+  if (!current) {
+    const candidate = { version: 1, id: randomId(), ...request };
+    await store.write('workflow', candidate);
+    current = await store.read('workflow');
+  }
+  if (!current) throw new Error('Workflow claim returned no state');
+  if (current && !requestsMatch(current, request)) {
+    const error = new Error(`Another ${current.operation} action is pending.`);
+    error.code = 'AGENT_NETWORK_ACTION_PENDING';
+    throw error;
+  }
+  return current;
+}
+
+async function handleFailure(error, store) {
+  if (error instanceof ActionState) {
+    if (error.status !== 'authorization_required') await store.remove('workflow');
+    return { status: error.status, ...error.data };
+  }
+  if (error?.status === 'authorization_required') {
+    return {
+      status: 'authorization_required',
+      message: error.message,
+      verificationUrl: error.verificationUrl,
+    };
+  }
+  const serialized = serializeFailure(error);
+  if (!serialized.retryable) await store.remove('workflow');
+  return { status: 'failed', ...serialized };
+}
+
+function serializeWithoutCleanup(error) {
+  if (error instanceof ActionState) return { status: error.status, ...error.data };
+  return { status: 'failed', ...serializeFailure(error) };
+}
+
+async function abandonWorkflow(store) {
+  const abandoned = await store.remove('workflow');
+  return {
+    status: 'completed',
+    operation: 'abandon_action',
+    data: { abandoned },
+  };
+}
+
+export function createActionExecutor({ api, workflowStore, randomId = randomUUID }) {
+  return {
+    async execute(value) {
+      let request;
+      try {
+        request = validateActionRequest(value);
+      } catch (error) {
+        return serializeWithoutCleanup(error);
+      }
+      if (request.operation === 'abandon_action') {
+        try {
+          return await abandonWorkflow(workflowStore);
+        } catch (error) {
+          return serializeWithoutCleanup(error);
+        }
+      }
+      let workflow;
+      try {
+        workflow = await loadWorkflow({ request, store: workflowStore, randomId });
+      } catch (error) {
+        return serializeWithoutCleanup(error);
+      }
+      try {
+        const context = createActionContext({ api, workflow });
+        const data = await ACTIONS[request.operation](context);
+        await workflowStore.remove('workflow');
+        return { status: 'completed', operation: request.operation, data };
+      } catch (error) {
+        return handleFailure(error, workflowStore);
+      }
+    },
+  };
+}

package/skills/tokensmind-agent-network-runtime/scripts/lib/action-validation.js

@@ -0,0 +1,61 @@
+import { requireInput } from './action-errors.js';
+
+export const OPERATIONS = Object.freeze([
+  'abandon_action',
+  'search_agents',
+  'get_my_agent',
+  'ensure_agent',
+  'contact_agent',
+  'list_inbox',
+  'get_conversation',
+  'reply',
+  'mark_read',
+  'withdraw_message',
+  'block_agent',
+  'unblock_agent',
+  'report',
+  'appeal',
+]);
+
+const OPERATION_SET = new Set(OPERATIONS);
+
+export function isObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function text(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+export function requiredText(input, field) {
+  const value = text(input?.[field]);
+  if (!value) requireInput([field]);
+  return value;
+}
+
+export function requiredId(input, field) {
+  return requiredText(input, field);
+}
+
+export function optionalLimit(value, fallback = 20) {
+  if (value === undefined || value === null || value === '') return fallback;
+  const number = Number(value);
+  if (!Number.isInteger(number) || number <= 0 || number > 100) {
+    requireInput(['limit'], 'limit must be an integer from 1 to 100.');
+  }
+  return number;
+}
+
+export function validateActionRequest(value) {
+  if (!isObject(value)) requireInput(['operation', 'input']);
+  const unexpected = Object.keys(value).filter((key) => !['operation', 'input'].includes(key));
+  if (unexpected.length) {
+    requireInput(['operation', 'input'], `Unsupported top-level fields: ${unexpected.join(', ')}`);
+  }
+  const operation = text(value.operation);
+  if (!OPERATION_SET.has(operation)) {
+    requireInput(['operation'], `Unsupported Agent Network operation: ${operation || '(empty)'}`);
+  }
+  if (value.input !== undefined && !isObject(value.input)) requireInput(['input']);
+  return { operation, input: value.input || {} };
+}

package/skills/tokensmind-agent-network-runtime/scripts/lib/agent-actions.js

@@ -0,0 +1,44 @@
+import { actionFailure, requireInput } from './action-errors.js';
+import { optionalLimit, text } from './action-validation.js';
+
+export async function searchAgents(context) {
+  const query = text(context.input.query);
+  const limit = optionalLimit(context.input.limit);
+  const params = new URLSearchParams({ limit: String(limit) });
+  if (query) params.set('q', query);
+  return context.get(`/agent-network-api/agents?${params}`);
+}
+
+export async function getMyAgent(context) {
+  const agents = await context.get('/agent-network-api/agents?mine=1');
+  if (!Array.isArray(agents)) {
+    actionFailure('AGENT_LIST_PROTOCOL_ERROR', 'Agent Network returned an invalid Agent list.');
+  }
+  if (agents.length > 1) {
+    actionFailure('AGENT_ACCOUNT_INVARIANT', 'The account has more than one Agent profile.');
+  }
+  return agents[0] || null;
+}
+
+function profileInput(input) {
+  const profile = input.agent || input.profile || {};
+  const name = text(profile.name);
+  const description = text(profile.description);
+  if (!name || !description) requireInput(['agent.name', 'agent.description']);
+  return { name, description };
+}
+
+export async function ensureAgent(context) {
+  const existing = await getMyAgent(context);
+  if (existing) return { agent: existing, created: false };
+  const result = await context.mutate({
+    method: 'POST',
+    path: '/agent-network-api/agents',
+    body: profileInput(context.input),
+    label: 'agent:create',
+  });
+  if (!result?.agent) {
+    actionFailure('AGENT_CREATE_PROTOCOL_ERROR', 'Agent creation returned no Agent.');
+  }
+  return { agent: result.agent, created: true };
+}

package/skills/tokensmind-agent-network-runtime/scripts/lib/api-client.js

@@ -0,0 +1,76 @@
+import os from 'node:os';
+import { createBrowserOpener } from './runtime/browser.js';
+import { createConnector } from './runtime/connector.js';
+import { DEFAULT_BASE_URL } from './runtime/constants.js';
+import { createCredentialStore } from './runtime/credentialStore.js';
+import { createHttpClient } from './runtime/httpClient.js';
+import { normalizeBaseUrl } from './runtime/requestPolicy.js';
+import { createWorkflowStore } from './workflow-store.js';
+
+const CLIENT_NAME = 'TokensMind Agent Network Runtime';
+const CLIENT_VERSION = '0.1.0';
+
+export class AuthorizationRequiredError extends Error {
+  constructor(verificationUrl) {
+    super('Complete Agent Network authorization in the browser, then retry the action.');
+    this.name = 'AuthorizationRequiredError';
+    this.status = 'authorization_required';
+    this.verificationUrl = verificationUrl;
+  }
+}
+
+function reportingBrowser({ browser, writeEvent }) {
+  return {
+    async open(url) {
+      try {
+        await browser.open(url);
+        writeEvent({ event: 'authorization_opened', verificationUrl: url });
+      } catch (error) {
+        writeEvent({ event: 'authorization_required', verificationUrl: url });
+        throw new AuthorizationRequiredError(url, { cause: error });
+      }
+    },
+  };
+}
+
+function resolveOptions(options) {
+  const platform = options.platform ?? process.platform;
+  return {
+    baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
+    stateDir: options.stateDir,
+    platform,
+    env: options.env ?? process.env,
+    homeDir: options.homeDir ?? os.homedir(),
+    hostname: options.hostname ?? os.hostname(),
+    browser: options.browser ?? createBrowserOpener({ platform }),
+    http: options.http ?? createHttpClient(),
+    store: options.store ?? null,
+    writeEvent: options.writeEvent ?? (() => {}),
+  };
+}
+
+export function createActionApi(options = {}) {
+  const {
+    baseUrl, stateDir, platform, env, homeDir, hostname, browser, http, store, writeEvent,
+  } = resolveOptions(options);
+  const origin = normalizeBaseUrl(baseUrl);
+  const resolvedStore = store || createCredentialStore({ stateDir, origin, platform, env, homeDir });
+  const workflowStore = createWorkflowStore({ stateDir, origin, platform, homeDir });
+  const connector = createConnector({
+    baseUrl: origin,
+    browser: reportingBrowser({ browser, writeEvent }),
+    client: {
+      name: CLIENT_NAME,
+      version: CLIENT_VERSION,
+      deviceName: hostname,
+      platform,
+    },
+    http,
+    store: resolvedStore,
+  });
+  return {
+    request: (request) => connector.execute(request),
+    store: resolvedStore,
+    workflowStore,
+  };
+}