@opengeni/sdk 0.57.0 → 1.0.0

package/dist/site.d.ts

@@ -0,0 +1,101 @@
+export { createSiteToolBridge, isSiteCatalogStaleError } from "./site-tool-bridge.js";
+export type { SiteToolBridge, SiteToolCaller, SiteToolCallRequest, CreateSiteToolBridgeOptions, } from "./site-tool-bridge.js";
+import { type OpenGeniWorkspaceTools } from "./tools.js";
+import { OpenGeniClient } from "./client.js";
+export { isSiteHttpRequest, serveSiteHttp, siteSessionPath, type SiteHttpRequest, } from "./site-http.js";
+import type { ToolGatewayCallRequest, ToolGatewayCallResponse, ToolGatewayCatalog, ToolGatewayDeclarationsResponse } from "./types.js";
+export declare const OPENGENI_SITE_BRIDGE_VERSION: 2;
+export declare const OPENGENI_SITE_BRIDGE_CONNECT: "opengeni.site.connect";
+export declare const OPENGENI_SITE_BRIDGE_READY: "opengeni.site.ready";
+export declare const OPENGENI_SITE_BRIDGE_REQUEST: "opengeni.site.request";
+export declare const OPENGENI_SITE_BRIDGE_RESPONSE: "opengeni.site.response";
+export declare const OPENGENI_SITE_BRIDGE_CANCEL: "opengeni.site.cancel";
+export declare const OPENGENI_SITE_BRIDGE_BOOTSTRAP_GLOBAL: "__opengeniSiteBridgeBootstrapV2";
+export declare const OPENGENI_SITE_LOCAL_CODEMODE_PATH: "/__opengeni/site-tools";
+export type OpenGeniSiteBridgeConnectMessage = {
+    type: typeof OPENGENI_SITE_BRIDGE_CONNECT;
+    version: typeof OPENGENI_SITE_BRIDGE_VERSION;
+};
+export type OpenGeniSiteBridgeReadyMessage = {
+    type: typeof OPENGENI_SITE_BRIDGE_READY;
+    version: typeof OPENGENI_SITE_BRIDGE_VERSION;
+};
+/** Site-originated calls cannot carry host-only approval tokens or Site-version authority. */
+export type OpenGeniSiteToolCallRequest = Omit<ToolGatewayCallRequest, "approvalToken" | "siteArtifactId" | "siteVersionId">;
+/** Host-filtered catalog projection. Tenant routing context never enters Site code. */
+export type OpenGeniSiteToolCatalog = Omit<ToolGatewayCatalog, "accountId" | "workspaceId">;
+export type OpenGeniSiteWorkspaceTools = OpenGeniWorkspaceTools<OpenGeniSiteToolCatalog>;
+export type OpenGeniSiteBridgeRequestMessage = {
+    type: typeof OPENGENI_SITE_BRIDGE_REQUEST;
+    version: typeof OPENGENI_SITE_BRIDGE_VERSION;
+    requestId: string;
+} & ({
+    method: "catalog";
+} | {
+    method: "call";
+    payload: OpenGeniSiteToolCallRequest;
+} | {
+    method: "declarations";
+});
+export type OpenGeniSiteBridgeCancelMessage = {
+    type: typeof OPENGENI_SITE_BRIDGE_CANCEL;
+    version: typeof OPENGENI_SITE_BRIDGE_VERSION;
+    requestId: string;
+};
+export type OpenGeniSiteBridgeResponseMessage = {
+    type: typeof OPENGENI_SITE_BRIDGE_RESPONSE;
+    version: typeof OPENGENI_SITE_BRIDGE_VERSION;
+    requestId: string;
+} & ({
+    ok: true;
+    value: OpenGeniSiteToolCatalog | ToolGatewayCallResponse | ToolGatewayDeclarationsResponse;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+        retryable: boolean;
+        outcomeUnknown?: boolean;
+    };
+});
+export type OpenGeniSiteClient = {
+    /** Ordinary SDK, including React session/composer methods and SSE streams. */
+    readonly client: OpenGeniClient;
+    /** Host-bound routing alias, not a credential or a caller-selected tenant. */
+    readonly workspaceId: string;
+    /** Workspace-bound typed facade. The parent host owns workspace identity and credentials. */
+    readonly tools: OpenGeniSiteWorkspaceTools;
+    close(): void;
+};
+export type OpenGeniSiteClientOptions = {
+    /** Advanced embedding seam; ordinary Sites accept bootstrap only from their exact parent. */
+    parentWindow?: MessageEventSource;
+    /** Advanced embedding seam for listening to the host's document-bound bootstrap message. */
+    siteWindow?: Pick<Window, "parent" | "addEventListener" | "removeEventListener">;
+    /** Test/embedding seam for an already document-bound host bootstrap port. */
+    bootstrapPort?: MessagePort;
+    connectTimeoutMs?: number;
+    requestTimeoutMs?: number;
+    createMessageChannel?: () => MessageChannel;
+    /** Local-preview seam. Top-level pages use this same-origin Codemode proxy automatically. */
+    localCodemodePath?: string | false;
+    /** Test/embedding seam for local-preview requests. */
+    fetch?: typeof globalThis.fetch;
+};
+export declare class OpenGeniSiteBridgeError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    readonly outcomeUnknown: boolean;
+    constructor(code: string, message: string, retryable?: boolean, outcomeUnknown?: boolean);
+}
+/**
+ * Create the browser client used by a Site. Published iframes use the parent
+ * MessagePort; top-level sandbox previews use the same-origin Codemode adapter.
+ * Credentials remain in the selected host and never enter Site code.
+ */
+export declare function createOpenGeniSiteClient(options?: OpenGeniSiteClientOptions): OpenGeniSiteClient;
+export declare function isOpenGeniSiteBridgeConnectMessage(value: unknown): value is OpenGeniSiteBridgeConnectMessage;
+export declare function isOpenGeniSiteBridgeRequestMessage(value: unknown): value is OpenGeniSiteBridgeRequestMessage;
+export declare function isOpenGeniSiteBridgeCancelMessage(value: unknown): value is OpenGeniSiteBridgeCancelMessage;
+/** Strip every host-only field before a call crosses the Site boundary. */
+export declare function sanitizeOpenGeniSiteToolCallRequest(value: ToolGatewayCallRequest): OpenGeniSiteToolCallRequest;

package/dist/site.js

@@ -0,0 +1,49 @@
+import {
+  OPENGENI_SITE_BRIDGE_BOOTSTRAP_GLOBAL,
+  OPENGENI_SITE_BRIDGE_CANCEL,
+  OPENGENI_SITE_BRIDGE_CONNECT,
+  OPENGENI_SITE_BRIDGE_READY,
+  OPENGENI_SITE_BRIDGE_REQUEST,
+  OPENGENI_SITE_BRIDGE_RESPONSE,
+  OPENGENI_SITE_BRIDGE_VERSION,
+  OPENGENI_SITE_LOCAL_CODEMODE_PATH,
+  OpenGeniSiteBridgeError,
+  createOpenGeniSiteClient,
+  createSiteToolBridge,
+  isOpenGeniSiteBridgeCancelMessage,
+  isOpenGeniSiteBridgeConnectMessage,
+  isOpenGeniSiteBridgeRequestMessage,
+  isSiteCatalogStaleError,
+  isSiteHttpRequest,
+  sanitizeOpenGeniSiteToolCallRequest,
+  serveSiteHttp,
+  siteSessionPath
+} from "./chunk-DUVIYER4.js";
+import "./chunk-4SMEOV3P.js";
+import "./chunk-FG3OO5LM.js";
+import "./chunk-APXVSSSY.js";
+import "./chunk-YIKA2QT4.js";
+import "./chunk-NC57YMUO.js";
+import "./chunk-V6GIY62B.js";
+export {
+  OPENGENI_SITE_BRIDGE_BOOTSTRAP_GLOBAL,
+  OPENGENI_SITE_BRIDGE_CANCEL,
+  OPENGENI_SITE_BRIDGE_CONNECT,
+  OPENGENI_SITE_BRIDGE_READY,
+  OPENGENI_SITE_BRIDGE_REQUEST,
+  OPENGENI_SITE_BRIDGE_RESPONSE,
+  OPENGENI_SITE_BRIDGE_VERSION,
+  OPENGENI_SITE_LOCAL_CODEMODE_PATH,
+  OpenGeniSiteBridgeError,
+  createOpenGeniSiteClient,
+  createSiteToolBridge,
+  isOpenGeniSiteBridgeCancelMessage,
+  isOpenGeniSiteBridgeConnectMessage,
+  isOpenGeniSiteBridgeRequestMessage,
+  isSiteCatalogStaleError,
+  isSiteHttpRequest,
+  sanitizeOpenGeniSiteToolCallRequest,
+  serveSiteHttp,
+  siteSessionPath
+};
+//# sourceMappingURL=site.js.map

package/dist/site.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/skills.d.ts

@@ -0,0 +1,75 @@
+/** Public shared Skill folder/history shapes; no runtime contracts dependency. */
+export type SkillFile = {
+    path: string;
+    content: string;
+};
+export type SkillScope = "workspace" | "organization" | "user";
+export type SkillRecord = {
+    removalOperationId?: string | null;
+    activationMode: "workspace_managed" | "session_selected";
+    pendingRevisionIds: string[];
+    id: string;
+    stableKey: string;
+    scope: SkillScope;
+    scopeVersion: number;
+    status: string;
+    activeRevisionId: string | null;
+    revisionId: string | null;
+    title: string | null;
+    description: string | null;
+    contentHash: string | null;
+    files: SkillFile[];
+    source: {
+        pluginId: string;
+        facetKey: string;
+        skillFacetId: string;
+    } | null;
+};
+export type SkillSummary = Omit<SkillRecord, "files">;
+export type SkillWriteReceipt = {
+    removed?: boolean | undefined;
+    operationId: string;
+    skillId: string;
+    revisionId: string;
+    outcome: "applied" | "pending" | "preserved";
+    pendingReason?: "approval" | "source_finalization" | undefined;
+    replayed: boolean;
+    decision?: "rejected" | undefined;
+    skillReview?: import("./types.js").SkillReviewReference | undefined;
+};
+export type SkillPublicationReceipt = SkillWriteReceipt & {
+    sourceOperationId: string;
+    activationEventId: string | null;
+};
+export type SkillSourceReleaseReceipt = {
+    skillId: string;
+    revisionId: string | null;
+    disposition: "deactivated" | "preserved" | "inactive";
+    eventId: string | null;
+    warning: string | null;
+};
+export type SaveWorkspaceSkillRequest = {
+    operationId: string;
+    skillId: string;
+    expectedRevisionId: string | null;
+    expectedScopeVersion: number;
+    scope?: SkillScope;
+    stableKey: string;
+    files: SkillFile[];
+    deletions?: string[];
+    reason: string;
+};
+export type ApplyWorkspaceSkillRevisionRequest = {
+    removalOperationId?: string;
+    operationId: string;
+    revisionId: string;
+    expectedRevisionId: string | null;
+    expectedScopeVersion: number;
+    reason: string;
+};
+export type RemoveWorkspaceSkillRequest = {
+    operationId: string;
+    expectedRevisionId: string | null;
+    expectedScopeVersion: number;
+    reason: string;
+};

package/dist/stream.d.ts

@@ -61,3 +61,5 @@ export declare function streamSessionEvents(transport: SessionEventStreamTranspo
 export declare function runBeforeLive(beforeLive: (() => void | Promise<void>) | undefined, timeoutMs: number, signal: AbortSignal | undefined): Promise<void>;
 export declare function jitteredDelay(delayMs: number, ratio: number): number;
 export declare function withStreamInactivityTimeout(stream: ReadableStream<Uint8Array>, timeoutMs: number, signal: AbortSignal | undefined): ReadableStream<Uint8Array>;
+/** Trusted SSE coverage attached non-enumerably to a streamed event. */
+export declare function sessionEventStreamCoveredThrough(event: SessionEvent): number | null;

package/dist/tenant-workspaces.d.ts

@@ -0,0 +1,47 @@
+import type { OpenGeniEmbeddingClient } from "./embedding-client.js";
+import type { Permission } from "./types.js";
+export type WorkspaceIdTarget = {
+    /**
+     * Your tenant id. With user isolation and no tenant, the user gets one
+     * workspace of their own, independent of any tenant.
+     */
+    tenant?: string | undefined;
+    user?: string | undefined;
+    /** External user identity source; defaults to the resolver's source. */
+    source?: string | undefined;
+};
+export type WorkspaceIdOptions = {
+    /**
+     * `tenant`: one workspace per tenant. `user`: a separate workspace for the
+     * user (per tenant when a tenant is given, otherwise one per user).
+     */
+    isolation: "tenant" | "user";
+};
+export type WorkspaceIdResolverOptions = {
+    /** The organization id, or a lazy lookup (for example derived from the API key). */
+    organizationId: string | (() => Promise<string>);
+    source: string;
+    /** Workspace display name; receives the tenant id, or the user id for a per-user workspace. */
+    workspaceName?: ((tenant: string) => string) | undefined;
+    /**
+     * Per-user workspaces only (user isolation): permissions for the one member
+     * this resolver adds explicitly, its owner. Replaces the defaults: workspace
+     * read, session create/read/control (including sending messages), file
+     * upload/read, and attaching the host's per-session MCP servers. No admin
+     * permissions are granted by default. Tenant workspaces rely on the API,
+     * which adds a missing member with those defaults on their first request.
+     * Existing grants are never changed here; change them with
+     * `updateExternalWorkspaceMember`. The organization API key must also allow
+     * the selected permissions.
+     */
+    memberPermissions?: readonly Permission[] | undefined;
+};
+/**
+ * Server-only workspace resolution using external workspace provisioning.
+ * Workspaces are created on first use and cached. A tenant workspace's members
+ * are added by the API on their first `asUser` request (the organization key
+ * needs `members:manage`). A per-user workspace stays single-user: the API
+ * never auto-admits anyone there, and this resolver adds its owner with a
+ * stable onboarding key, so retries never restore a revoked grant.
+ */
+export declare function createWorkspaceIdResolver(client: Pick<OpenGeniEmbeddingClient, "ensureWorkspace" | "addExternalWorkspaceMember">, options: WorkspaceIdResolverOptions): (target: WorkspaceIdTarget, resolution: WorkspaceIdOptions) => Promise<string>;

package/dist/tenant-workspaces.js

@@ -0,0 +1,8 @@
+import {
+  createWorkspaceIdResolver
+} from "./chunk-LY2K6ELJ.js";
+import "./chunk-V6GIY62B.js";
+export {
+  createWorkspaceIdResolver
+};
+//# sourceMappingURL=tenant-workspaces.js.map

package/dist/tenant-workspaces.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/tool-auth.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Per-user credentials for a product's own MCP tool server.
+ *
+ * `createSessionProxyHandler({ toolServer })` mints a short-lived token for the
+ * user its `resolve` hook authenticated, attaches it to each session it creates,
+ * and refreshes it on every message, approval, and answer. The product's MCP
+ * endpoint calls {@link verifyToolRequest} on every request and scopes all data
+ * access to the returned identity, never to ids the model supplied.
+ *
+ * Wire format (for non-Node verifiers): an HS256 JWT in `Authorization: Bearer`,
+ * signed with the hex key from {@link deriveToolTokenKey} (`HMAC-SHA256(key =
+ * secret, message = "opengeni-tool-token:v1")`, where `secret` is
+ * `OPENGENI_API_KEY` unless configured). Give a non-Node verifier that derived
+ * key, never the organization key. Claims: `iss` = `"opengeni-session-proxy"`,
+ * `aud` = the tool server URL, `sub` = the external user id, `workspace_id`,
+ * `source`, optional `tenant`, `iat`, `exp`.
+ */
+/** `iss` of every tool token. */
+export declare const TOOL_TOKEN_ISSUER = "opengeni-session-proxy";
+/** HMAC message used to derive the signing key from the secret. */
+export declare const TOOL_TOKEN_KEY_LABEL = "opengeni-tool-token:v1";
+/** Default token lifetime: 24 hours, refreshed on every message, approval, and answer. */
+export declare const TOOL_TOKEN_DEFAULT_TTL_SECONDS: number;
+/** Default `toolServer.url` and `verifyToolRequest` audience. */
+export declare const TOOL_SERVER_URL_ENV = "OPENGENI_TOOL_SERVER_URL";
+/** The user a verified tool request acts for. */
+export type ToolRequestIdentity = {
+    /** External user id the session proxy's `resolve` hook authenticated. */
+    user: string;
+    /** Tenant from `resolve`, when it returned one. */
+    tenant?: string | undefined;
+    workspaceId: string;
+    /** External identity source (same as the proxy's `asUser` source). */
+    source: string;
+    expiresAt: Date;
+};
+export type VerifyToolRequestOptions = {
+    /** Signing secret. Defaults to `OPENGENI_API_KEY`; must match the proxy's. */
+    secret?: string | undefined;
+    /**
+     * Exact tool server URL the token must be issued for (the proxy's
+     * `toolServer.url`). Defaults to `OPENGENI_TOOL_SERVER_URL`.
+     */
+    audience?: string | undefined;
+};
+/** A Web `Request`, or a Node/Express request (`headers` plus `originalUrl`/`url`). */
+export type ToolRequestLike = Request | {
+    headers: Record<string, string | string[] | undefined>;
+    originalUrl?: string | undefined;
+    url?: string | undefined;
+};
+/** Missing, expired, forged, or misdirected tool token. Respond with `status` (401). */
+export declare class ToolRequestError extends Error {
+    readonly code: string;
+    readonly status = 401;
+    constructor(code: string);
+    /** A ready 401 response with a `WWW-Authenticate: Bearer` challenge. */
+    toResponse(): Response;
+}
+/**
+ * Verify the tool token on one MCP request and return who it acts for.
+ * Throws {@link ToolRequestError} (401) for every invalid token. Call it on
+ * every request, before any tool runs.
+ *
+ * ```ts
+ * const user = await verifyToolRequest(request); // { user, tenant, workspaceId }
+ * ```
+ */
+export declare function verifyToolRequest(request: ToolRequestLike, options?: VerifyToolRequestOptions): Promise<ToolRequestIdentity>;
+/** Mint one tool token. The session proxy calls this; products rarely need to. */
+export declare function mintToolToken(input: {
+    /** Tool server URL; becomes `aud`. */
+    audience: string;
+    user: string;
+    tenant?: string | undefined;
+    workspaceId: string;
+    source: string;
+    secret?: string | undefined;
+    ttlSeconds?: number | undefined;
+}): Promise<string>;
+/**
+ * The hex HS256 key tool tokens are signed with. Give this (not the
+ * organization key) to a tool server written in Python, Ruby, Go, and so on.
+ */
+export declare function deriveToolTokenKey(secret?: string): Promise<string>;
+/** The configured secret, else `OPENGENI_API_KEY`. Throws when neither is set. */
+export declare function resolveToolTokenSecret(secret: string | undefined): string;

package/dist/tool-auth.js

@@ -0,0 +1,23 @@
+import {
+  TOOL_SERVER_URL_ENV,
+  TOOL_TOKEN_DEFAULT_TTL_SECONDS,
+  TOOL_TOKEN_ISSUER,
+  TOOL_TOKEN_KEY_LABEL,
+  ToolRequestError,
+  deriveToolTokenKey,
+  mintToolToken,
+  resolveToolTokenSecret,
+  verifyToolRequest
+} from "./chunk-U6CV2SXO.js";
+export {
+  TOOL_SERVER_URL_ENV,
+  TOOL_TOKEN_DEFAULT_TTL_SECONDS,
+  TOOL_TOKEN_ISSUER,
+  TOOL_TOKEN_KEY_LABEL,
+  ToolRequestError,
+  deriveToolTokenKey,
+  mintToolToken,
+  resolveToolTokenSecret,
+  verifyToolRequest
+};
+//# sourceMappingURL=tool-auth.js.map

package/dist/tool-auth.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/tool-display-metadata.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDisplayMetadata } from "@opengeni/contracts";
+/** Browser/native-safe event projection; do not import server schema runtimes. */
+export declare function parseToolDisplayMetadata(value: unknown): ToolDisplayMetadata | undefined;

package/dist/tools-FXBLUWAE.js

@@ -0,0 +1,12 @@
+import {
+  OpenGeniToolCallError,
+  OpenGeniToolReapprovalRequiredError,
+  OpenGeniToolsClient
+} from "./chunk-4SMEOV3P.js";
+import "./chunk-V6GIY62B.js";
+export {
+  OpenGeniToolCallError,
+  OpenGeniToolReapprovalRequiredError,
+  OpenGeniToolsClient
+};
+//# sourceMappingURL=tools-FXBLUWAE.js.map

package/dist/tools-FXBLUWAE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/tools.d.ts

@@ -0,0 +1,61 @@
+import type { ToolGatewayApprovalResponse, ToolGatewayCatalog, ToolGatewayDeclarationsResponse, ToolGatewayIdentity, ToolGatewayResult } from "./types.js";
+export type OpenGeniToolCallOptions = {
+    operationId?: string;
+    signal?: AbortSignal;
+    refreshCatalog?: boolean;
+    /** Server-issued, single-use capability returned by `$approve`. */
+    approvalToken?: string;
+};
+export type OpenGeniToolFunction<TArguments extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = (argumentsValue?: TArguments, options?: OpenGeniToolCallOptions) => Promise<TResult>;
+export interface OpenGeniDynamicToolNamespace {
+    readonly [key: string]: OpenGeniDynamicToolNode;
+}
+export type OpenGeniDynamicToolNode = OpenGeniDynamicToolNamespace & OpenGeniToolFunction;
+/** Declaration-generation target for one exact workspace catalog. */
+export interface OpenGeniGeneratedTools {
+}
+export type OpenGeniWorkspaceTools<TCatalog extends Pick<ToolGatewayCatalog, "version" | "generation" | "digest" | "createdAt" | "entries"> = ToolGatewayCatalog> = OpenGeniGeneratedTools & OpenGeniDynamicToolNamespace & {
+    readonly $catalog: (options?: {
+        refresh?: boolean;
+        signal?: AbortSignal;
+    }) => Promise<TCatalog>;
+    readonly $call: (identity: ToolGatewayIdentity, argumentsValue?: Record<string, unknown>, options?: OpenGeniToolCallOptions) => Promise<unknown>;
+    readonly $approve: (identity: ToolGatewayIdentity, argumentsValue?: Record<string, unknown>, options?: {
+        operationId?: string;
+        signal?: AbortSignal;
+    }) => Promise<ToolGatewayApprovalResponse>;
+    readonly $declarations: (options?: {
+        signal?: AbortSignal;
+    }) => Promise<ToolGatewayDeclarationsResponse>;
+};
+export interface OpenGeniToolTransport {
+    requestJson<T>(method: string, path: string, body?: unknown, query?: Record<string, string>, options?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<T>;
+}
+export interface OpenGeniToolsFacade {
+    forWorkspace(workspaceId: string): OpenGeniWorkspaceTools;
+}
+export declare class OpenGeniToolCallError extends Error {
+    readonly result: ToolGatewayResult;
+    readonly code: string;
+    readonly retryable: boolean;
+    readonly outcomeUnknown: boolean;
+    constructor(result: ToolGatewayResult);
+}
+/** A catalog refresh invalidated the single-use approval capability for this call. */
+export declare class OpenGeniToolReapprovalRequiredError extends Error {
+    readonly operationId: string;
+    readonly previousCatalogDigest: string;
+    readonly catalogDigest: string;
+    readonly identity: ToolGatewayIdentity;
+    readonly code: "tool_reapproval_required";
+    readonly retryable = false;
+    constructor(operationId: string, previousCatalogDigest: string, catalogDigest: string, identity: ToolGatewayIdentity);
+}
+export declare class OpenGeniToolsClient implements OpenGeniToolsFacade {
+    private readonly transport;
+    constructor(transport: OpenGeniToolTransport);
+    forWorkspace(workspaceId: string): OpenGeniWorkspaceTools;
+}