@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/ipc/skill-socket-path.ts

@@ -1,20 +0,0 @@
-/**
- * Skill IPC socket-path helper — resolves the path to `assistant-skill.sock`,
- * the Unix domain socket that first-party skill processes use to talk to the
- * daemon.
- *
- * Delegates to the shared `resolveIpcSocketPath` in `socket-path.ts`.
- */
-
-import {
-  type IpcSocketPathResolution,
-  resolveIpcSocketPath,
-} from "./socket-path.js";
-
-export function resolveSkillIpcSocketPath(): IpcSocketPathResolution {
-  return resolveIpcSocketPath("assistant-skill");
-}
-
-export function getSkillSocketPath(): string {
-  return resolveSkillIpcSocketPath().path;
-}

package/src/jobs/register-job-handlers.ts

@@ -1,74 +0,0 @@
-import { buildConversationSummaryJob } from "../conversations/job-handlers/summarization.js";
-import { generateConversationStartersJob } from "../home/job-handlers/conversation-starters.js";
-import { mediaProcessingJob } from "../media/job-handlers/media-processing.js";
-import {
-  pruneOldConversationsJob,
-  pruneOldLlmRequestLogsJob,
-  pruneOldTraceEventsJob,
-} from "../persistence/job-handlers/cleanup.js";
-import { registerJobHandler } from "../persistence/jobs-worker.js";
-import {
-  registerDefaultPluginJobHandlers,
-  registerDefaultPluginPersistenceHooks,
-} from "../plugins/defaults/index.js";
-import { getRegisteredJobHandlers } from "../plugins/job-handler-registry.js";
-import { conversationAnalyzeJob } from "../runtime/services/conversation-analyze-job.js";
-
-/**
- * Register every background-job handler into the worker's dispatch table
- * (`registerJobHandler` in `persistence/jobs-worker`).
- *
- * Plugin-contributed handlers (memory, and any future plugin) flow through the
- * global job-handler registry; the remaining handlers belong to domains that are
- * not plugins (persistence cleanup, conversations, media, home, runtime) and are
- * wired here directly.
- *
- * Idempotent: registering a type twice overwrites with the same handler, so
- * repeated calls (e.g. from the daemon supervisor and the standalone worker
- * process) are safe.
- */
-export function registerMemoryJobHandlers(): void {
-  // Forward plugin-contributed job handlers into the worker. Ensure the default
-  // plugins' contributions are in the registry first: the standalone worker
-  // process does not run plugin bootstrap, so it must self-register the defaults
-  // here. Idempotent — on the daemon path bootstrap has already registered them
-  // (plus any user plugins, which this union also picks up).
-  registerDefaultPluginJobHandlers();
-  // The standalone worker runs fork-based memory retrospectives, which carry
-  // per-conversation memory state through the persistence-lifecycle seam. The
-  // daemon wires that seam at bootstrap; the worker must self-register it here
-  // too, or `onConversationForked` is the no-op and the retrospective fork
-  // silently drops the carried activation/injection/graph/retrospective state.
-  registerDefaultPluginPersistenceHooks();
-  for (const { type, handler } of getRegisteredJobHandlers()) {
-    registerJobHandler(type, handler);
-  }
-
-  // Non-plugin domain handlers. Each is registered behind an arrow that reads
-  // the imported binding at dispatch time rather than capturing it eagerly, so a
-  // per-test `mock.module` of the underlying handler is honored.
-  registerJobHandler("prune_old_conversations", (job, config) =>
-    pruneOldConversationsJob(job, config),
-  );
-  registerJobHandler("prune_old_llm_request_logs", (job, config) =>
-    pruneOldLlmRequestLogsJob(job, config),
-  );
-  registerJobHandler("prune_old_trace_events", (job, config) =>
-    pruneOldTraceEventsJob(job, config),
-  );
-  registerJobHandler("build_conversation_summary", async (job, config) => {
-    // Stale rows enqueued before v2 was enabled must not consume the
-    // `conversationSummarization` LLM budget — v2 readers do not consume
-    // `memorySummaries`, mirroring the `graph_extract` gate in the memory
-    // plugin's job handlers.
-    if (config.memory.v2.enabled) return;
-    await buildConversationSummaryJob(job, config);
-  });
-  registerJobHandler("media_processing", (job) => mediaProcessingJob(job));
-  registerJobHandler("conversation_analyze", (job, config) =>
-    conversationAnalyzeJob(job, config),
-  );
-  registerJobHandler("generate_conversation_starters", (job) =>
-    generateConversationStartersJob(job),
-  );
-}

package/src/persistence/invite-store.ts

@@ -1,481 +0,0 @@
-/**
- * CRUD store for assistant ingress invites.
- *
- * Invites allow external users to join an assistant's ingress (inbox) on a
- * specific channel. Each invite carries a SHA-256 hashed token — the raw
- * token is returned exactly once at creation time and never stored.
- */
-
-import { createHash, randomBytes, randomUUID } from "node:crypto";
-
-import { and, desc, eq, gt } from "drizzle-orm";
-
-import { getDb } from "./db-connection.js";
-import { assistantIngressInvites } from "./schema.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export type InviteStatus = "active" | "redeemed" | "revoked" | "expired";
-
-export interface IngressInvite {
-  id: string;
-  sourceChannel: string;
-  tokenHash: string;
-  sourceConversationId: string | null;
-  note: string | null;
-  maxUses: number;
-  useCount: number;
-  expiresAt: number;
-  status: InviteStatus;
-  redeemedByExternalUserId: string | null;
-  redeemedByExternalChatId: string | null;
-  redeemedAt: number | null;
-  // Voice invite fields (null for non-voice invites)
-  expectedExternalUserId: string | null;
-  voiceCodeHash: string | null;
-  voiceCodeDigits: number | null;
-  // 6-digit invite code hash (null for voice invites which use voiceCodeHash)
-  inviteCodeHash: string | null;
-  // Display metadata for personalized voice prompts (null for non-voice invites)
-  friendName: string | null;
-  guardianName: string | null;
-  // Contact binding — every invite is bound to a specific contact
-  contactId: string;
-  createdAt: number;
-  updatedAt: number;
-}
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const DEFAULT_EXPIRY_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-export function hashToken(rawToken: string): string {
-  return createHash("sha256").update(rawToken).digest("hex");
-}
-
-function generateToken(): string {
-  // 32 bytes = 256 bits of entropy, base64url-encoded to a 43-character URL-safe string.
-  return randomBytes(32).toString("base64url");
-}
-
-function rowToInvite(
-  row: typeof assistantIngressInvites.$inferSelect,
-): IngressInvite {
-  return {
-    id: row.id,
-    sourceChannel: row.sourceChannel,
-    tokenHash: row.tokenHash,
-    sourceConversationId: row.sourceConversationId,
-    note: row.note,
-    maxUses: row.maxUses,
-    useCount: row.useCount,
-    expiresAt: row.expiresAt,
-    status: row.status as InviteStatus,
-    redeemedByExternalUserId: row.redeemedByExternalUserId,
-    redeemedByExternalChatId: row.redeemedByExternalChatId,
-    redeemedAt: row.redeemedAt,
-    expectedExternalUserId: row.expectedExternalUserId,
-    voiceCodeHash: row.voiceCodeHash,
-    voiceCodeDigits: row.voiceCodeDigits,
-    inviteCodeHash: row.inviteCodeHash,
-    friendName: row.friendName,
-    guardianName: row.guardianName,
-    contactId: row.contactId,
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// createInvite
-// ---------------------------------------------------------------------------
-
-export function createInvite(params: {
-  sourceChannel: string;
-  contactId: string;
-  sourceConversationId?: string;
-  note?: string;
-  maxUses?: number;
-  expiresInMs?: number;
-  // Voice invite metadata (all optional — omitted for non-voice invites)
-  expectedExternalUserId?: string;
-  voiceCodeHash?: string;
-  voiceCodeDigits?: number;
-  // 6-digit invite code hash (for non-voice invites)
-  inviteCodeHash?: string;
-  friendName?: string;
-  guardianName?: string;
-}): { invite: IngressInvite; rawToken: string } {
-  const db = getDb();
-  const now = Date.now();
-  const id = randomUUID();
-  const rawToken = generateToken();
-  const tokenH = hashToken(rawToken);
-
-  const row = {
-    id,
-    sourceChannel: params.sourceChannel,
-    tokenHash: tokenH,
-    sourceConversationId: params.sourceConversationId ?? null,
-    note: params.note ?? null,
-    maxUses: params.maxUses ?? 1,
-    useCount: 0,
-    expiresAt: now + (params.expiresInMs ?? DEFAULT_EXPIRY_MS),
-    status: "active" as const,
-    redeemedByExternalUserId: null,
-    redeemedByExternalChatId: null,
-    redeemedAt: null,
-    expectedExternalUserId: params.expectedExternalUserId ?? null,
-    voiceCodeHash: params.voiceCodeHash ?? null,
-    voiceCodeDigits: params.voiceCodeDigits ?? null,
-    inviteCodeHash: params.inviteCodeHash ?? null,
-    friendName: params.friendName ?? null,
-    guardianName: params.guardianName ?? null,
-    contactId: params.contactId,
-    createdAt: now,
-    updatedAt: now,
-  };
-
-  db.insert(assistantIngressInvites).values(row).run();
-
-  return { invite: rowToInvite(row), rawToken };
-}
-
-// ---------------------------------------------------------------------------
-// listInvites
-// ---------------------------------------------------------------------------
-
-export function listInvites(params: {
-  sourceChannel?: string;
-  status?: InviteStatus;
-  limit?: number;
-  offset?: number;
-}): IngressInvite[] {
-  const db = getDb();
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const conditions: any[] = [];
-
-  if (params.sourceChannel) {
-    conditions.push(
-      eq(assistantIngressInvites.sourceChannel, params.sourceChannel),
-    );
-  }
-  if (params.status) {
-    conditions.push(eq(assistantIngressInvites.status, params.status));
-  }
-
-  const query = db.select().from(assistantIngressInvites);
-
-  const rows = (conditions.length > 0 ? query.where(and(...conditions)) : query)
-    .orderBy(desc(assistantIngressInvites.createdAt))
-    .limit(params.limit ?? 100)
-    .offset(params.offset ?? 0)
-    .all();
-
-  return rows.map(rowToInvite);
-}
-
-// ---------------------------------------------------------------------------
-// revokeInvite
-// ---------------------------------------------------------------------------
-
-export function revokeInvite(inviteId: string): IngressInvite | null {
-  const db = getDb();
-  const now = Date.now();
-
-  const existing = db
-    .select()
-    .from(assistantIngressInvites)
-    .where(
-      and(
-        eq(assistantIngressInvites.id, inviteId),
-        eq(assistantIngressInvites.status, "active"),
-      ),
-    )
-    .get();
-
-  if (!existing) return null;
-
-  db.update(assistantIngressInvites)
-    .set({ status: "revoked", updatedAt: now })
-    .where(eq(assistantIngressInvites.id, inviteId))
-    .run();
-
-  return rowToInvite({ ...existing, status: "revoked", updatedAt: now });
-}
-
-// ---------------------------------------------------------------------------
-// recordInviteUse — consume one use without creating a member row
-// ---------------------------------------------------------------------------
-
-/**
- * Increment an invite's use count and record redemption metadata without
- * inserting a new member row. Used when reactivating an existing inactive
- * member via invite — the member row already exists and just needs an
- * update, so the transactional INSERT in `redeemInvite` would hit a
- * unique-key constraint.
- *
- * Returns `true` if the use was recorded, or `false` if the invite was
- * concurrently revoked/expired (the WHERE clause constrains to
- * `status = 'active'` so a stale write is impossible).
- */
-export function recordInviteUse(params: {
-  inviteId: string;
-  externalUserId?: string;
-  externalChatId?: string;
-}): boolean {
-  const db = getDb();
-  const now = Date.now();
-
-  const invite = db
-    .select()
-    .from(assistantIngressInvites)
-    .where(eq(assistantIngressInvites.id, params.inviteId))
-    .get();
-
-  if (!invite) return false;
-
-  const newUseCount = invite.useCount + 1;
-  const newStatus = newUseCount >= invite.maxUses ? "redeemed" : "active";
-
-  // Constrain the update to active invites so a concurrent revoke/expire
-  // prevents this write rather than silently overwriting the new status.
-  db.update(assistantIngressInvites)
-    .set({
-      useCount: newUseCount,
-      status: newStatus,
-      redeemedByExternalUserId: params.externalUserId ?? null,
-      redeemedByExternalChatId: params.externalChatId ?? null,
-      redeemedAt: now,
-      updatedAt: now,
-    })
-    .where(
-      and(
-        eq(assistantIngressInvites.id, invite.id),
-        eq(assistantIngressInvites.status, "active"),
-      ),
-    )
-    .run();
-
-  // Re-read to confirm the update took effect (the WHERE clause constrains
-  // to status = 'active', so a concurrent revoke/expire would prevent it).
-  const updated = db
-    .select({ useCount: assistantIngressInvites.useCount })
-    .from(assistantIngressInvites)
-    .where(eq(assistantIngressInvites.id, invite.id))
-    .get();
-
-  return !!updated && updated.useCount === newUseCount;
-}
-
-// ---------------------------------------------------------------------------
-// markInviteExpired
-// ---------------------------------------------------------------------------
-
-/**
- * Transition an invite's status to 'expired' in storage. This is safe to call
- * even if the invite is already expired — the WHERE clause scopes the update
- * to 'active' rows so it becomes a no-op in that case.
- */
-export function markInviteExpired(inviteId: string): void {
-  const db = getDb();
-  const now = Date.now();
-
-  db.update(assistantIngressInvites)
-    .set({ status: "expired", updatedAt: now })
-    .where(
-      and(
-        eq(assistantIngressInvites.id, inviteId),
-        eq(assistantIngressInvites.status, "active"),
-      ),
-    )
-    .run();
-}
-
-// ---------------------------------------------------------------------------
-// findByTokenHash
-// ---------------------------------------------------------------------------
-
-export function findByTokenHash(tokenHash: string): IngressInvite | null {
-  const db = getDb();
-
-  const row = db
-    .select()
-    .from(assistantIngressInvites)
-    .where(eq(assistantIngressInvites.tokenHash, tokenHash))
-    .get();
-
-  return row ? rowToInvite(row) : null;
-}
-
-// ---------------------------------------------------------------------------
-// findById
-// ---------------------------------------------------------------------------
-
-export function findById(inviteId: string): IngressInvite | null {
-  const db = getDb();
-  const row = db
-    .select()
-    .from(assistantIngressInvites)
-    .where(eq(assistantIngressInvites.id, inviteId))
-    .get();
-  return row ? rowToInvite(row) : null;
-}
-
-// ---------------------------------------------------------------------------
-// findActiveVoiceInvites
-// ---------------------------------------------------------------------------
-
-/**
- * Find all active voice invites bound to a specific caller identity.
- * Used by the voice invite redemption flow to locate candidate invites
- * before code hash matching.
- */
-export function findActiveVoiceInvites(params: {
-  expectedExternalUserId: string;
-}): IngressInvite[] {
-  const db = getDb();
-
-  const rows = db
-    .select()
-    .from(assistantIngressInvites)
-    .where(
-      and(
-        eq(assistantIngressInvites.sourceChannel, "phone"),
-        eq(assistantIngressInvites.status, "active"),
-        eq(
-          assistantIngressInvites.expectedExternalUserId,
-          params.expectedExternalUserId,
-        ),
-      ),
-    )
-    .all();
-
-  return rows.map(rowToInvite);
-}
-
-// ---------------------------------------------------------------------------
-// claimA2AInvite — validate + consume an A2A invite token
-// ---------------------------------------------------------------------------
-
-export function claimA2AInvite(params: {
-  tokenHash: string;
-  redeemedByExternalUserId: string;
-}): { claimed: boolean; invite: IngressInvite | null; error?: string } {
-  const invite = findByTokenHash(params.tokenHash);
-
-  if (!invite) {
-    return { claimed: false, invite: null, error: "not_found" };
-  }
-
-  if (invite.sourceChannel !== "a2a") {
-    return { claimed: false, invite, error: "wrong_channel" };
-  }
-
-  // Idempotency: if already redeemed by the same acceptor, return success
-  if (invite.status === "redeemed") {
-    if (invite.redeemedByExternalUserId === params.redeemedByExternalUserId) {
-      return { claimed: true, invite };
-    }
-    return { claimed: false, invite, error: "already_redeemed_by_other" };
-  }
-
-  if (invite.status !== "active") {
-    return { claimed: false, invite, error: "not_found" };
-  }
-
-  if (Date.now() >= invite.expiresAt) {
-    markInviteExpired(invite.id);
-    return { claimed: false, invite, error: "expired" };
-  }
-
-  if (invite.useCount >= invite.maxUses) {
-    return { claimed: false, invite, error: "already_redeemed" };
-  }
-
-  const recorded = recordInviteUse({
-    inviteId: invite.id,
-    externalUserId: params.redeemedByExternalUserId,
-  });
-
-  if (!recorded) {
-    return { claimed: false, invite, error: "not_found" };
-  }
-
-  // Re-read to get updated state
-  const updated = findByTokenHash(params.tokenHash);
-  return { claimed: true, invite: updated };
-}
-
-// ---------------------------------------------------------------------------
-// findByInviteCodeHash
-// ---------------------------------------------------------------------------
-
-/**
- * Find an active invite by its 6-digit invite code hash, scoped to a specific
- * source channel. Channel scoping is required because 6-digit codes are drawn
- * from a small keyspace and can collide across channels — without it, `.get()`
- * could return an arbitrary match, leading to nondeterministic redemption or
- * false channel-mismatch failures downstream.
- */
-export function findByInviteCodeHash(
-  hash: string,
-  sourceChannel: string,
-): IngressInvite | null {
-  const db = getDb();
-
-  const row = db
-    .select()
-    .from(assistantIngressInvites)
-    .where(
-      and(
-        eq(assistantIngressInvites.inviteCodeHash, hash),
-        eq(assistantIngressInvites.sourceChannel, sourceChannel),
-        eq(assistantIngressInvites.status, "active"),
-      ),
-    )
-    .get();
-
-  return row ? rowToInvite(row) : null;
-}
-
-// ---------------------------------------------------------------------------
-// findByInviteCodeHashAnyChannel
-// ---------------------------------------------------------------------------
-
-/**
- * Find an active invite by its 6-digit invite code hash without channel
- * scoping. Used as a fallback after a channel-scoped lookup fails, to
- * distinguish "code doesn't exist" from "code exists but for a different
- * channel" — the latter should produce a channel_mismatch response instead
- * of silently falling through.
- */
-export function findByInviteCodeHashAnyChannel(
-  hash: string,
-): IngressInvite | null {
-  const db = getDb();
-  const now = Date.now();
-
-  const row = db
-    .select()
-    .from(assistantIngressInvites)
-    .where(
-      and(
-        eq(assistantIngressInvites.inviteCodeHash, hash),
-        eq(assistantIngressInvites.status, "active"),
-        gt(assistantIngressInvites.expiresAt, now),
-      ),
-    )
-    .get();
-
-  return row ? rowToInvite(row) : null;
-}

package/src/plugins/job-handler-registry.ts

@@ -1,94 +0,0 @@
-/**
- * Global background-job-handler registry.
- *
- * Background-job handlers are a first-party plugin contribution, registered the
- * same way `tools`, `routes`, and `injectors` are: the bootstrap
- * (`external-plugins-bootstrap.ts`) reads each plugin's `jobHandlers` field and
- * registers it here before the plugin's `init()` runs. The general job worker's
- * registration entry (`jobs/register-job-handlers.ts`) reads the union via
- * {@link getRegisteredJobHandlers} and forwards each handler into the worker's
- * dispatch table (`registerJobHandler` in `persistence/jobs-worker.ts`).
- *
- * Unlike injectors, job handlers carry no order: dispatch is a keyed lookup by
- * job `type`, so a `type` must be globally unique across every plugin. The
- * registry rejects a duplicate `type` the same way the injector registry rejects
- * a duplicate injector name. Contribution order is irrelevant — the worker's
- * dispatch map is keyed by type — so {@link getRegisteredJobHandlers} returns the
- * union in plain registration order with no sort.
- */
-
-import { getLogger } from "../util/logger.js";
-import type { JobHandlerEntry } from "./types.js";
-
-const log = getLogger("job-handler-registry");
-
-/**
- * Job handlers contributed by each plugin, keyed by plugin name. `Map` iteration
- * preserves insertion (registration) order; within a plugin the array order is
- * preserved. Neither affects dispatch (keyed by `type`).
- */
-const jobHandlersByPlugin = new Map<string, readonly JobHandlerEntry[]>();
-
-/**
- * Register the job handlers contributed by `pluginName`. Job-handler `type`s must
- * be globally unique; a `type` already claimed by a *different* plugin throws.
- * Re-registering the same plugin replaces its prior set (idempotent for hot
- * reload and test re-setup), so a plugin re-running its own registration is a
- * silent replace rather than a duplicate-type throw.
- */
-export function registerPluginJobHandlers(
-  pluginName: string,
-  handlers: readonly JobHandlerEntry[],
-): void {
-  const seenInContribution = new Set<string>();
-  for (const entry of handlers) {
-    if (seenInContribution.has(entry.type)) {
-      throw new Error(
-        `Plugin "${pluginName}" contributes duplicate job-handler type "${entry.type}"`,
-      );
-    }
-    seenInContribution.add(entry.type);
-    for (const [owner, existing] of jobHandlersByPlugin) {
-      if (owner === pluginName) continue;
-      if (existing.some((e) => e.type === entry.type)) {
-        throw new Error(
-          `Job-handler type "${entry.type}" contributed by plugin "${pluginName}" is already registered by plugin "${owner}"`,
-        );
-      }
-    }
-  }
-  jobHandlersByPlugin.set(pluginName, handlers);
-  log.info(
-    { plugin: pluginName, count: handlers.length },
-    "Plugin job handlers registered",
-  );
-}
-
-/**
- * Remove the job handlers contributed by `pluginName`. No-op when the plugin
- * never contributed job handlers, so it is safe to call on every teardown path.
- */
-export function unregisterPluginJobHandlers(pluginName: string): void {
-  if (jobHandlersByPlugin.delete(pluginName)) {
-    log.info({ plugin: pluginName }, "Plugin job handlers unregistered");
-  }
-}
-
-/**
- * The union of every registered plugin's job-handler contributions, in
- * registration order. `type`s are globally unique (enforced at registration), so
- * the consumer can forward each entry into the worker's keyed dispatch table
- * without further dedupe.
- */
-export function getRegisteredJobHandlers(): JobHandlerEntry[] {
-  const all: JobHandlerEntry[] = [];
-  for (const handlers of jobHandlersByPlugin.values()) {
-    all.push(...handlers);
-  }
-  return all;
-}
-
-/** Drop every registration. Exposed for test isolation. */
-export function clearJobHandlerRegistry(): void {
-  jobHandlersByPlugin.clear();
-}

package/src/providers/cache-control.ts

@@ -1,26 +0,0 @@
-import type { ContentBlock } from "./types.js";
-
-/**
- * Build a text content block carrying an ephemeral `cache_control` breakpoint
- * with a 1h TTL, marking a byte-stable prefix the provider KV cache should
- * persist across calls.
- *
- * The Anthropic SDK accepts the field as an extra property on text blocks, but
- * the internal `TextContent` type intentionally omits it (only the Anthropic
- * provider transforms it onto the wire — block-level `cache_control` is
- * preserved through `toAnthropicBlockSafe`), so we reach through a `Record`
- * cast for the same reason `anthropic/client.ts` does — it keeps the core
- * types provider-agnostic. The 1h TTL matches the provider's auto-applied
- * breakpoints (see `cacheTtl` in `providers/anthropic/client.ts`); the
- * `extended-cache-ttl-2025-04-11` beta header is added unconditionally for
- * non-Haiku models in `client.ts` (Haiku models have the `ttl` stripped
- * provider-side), so this works without any call-site config.
- */
-export function cachedTextBlock(text: string): ContentBlock {
-  const block: ContentBlock = { type: "text", text };
-  (block as unknown as Record<string, unknown>).cache_control = {
-    type: "ephemeral",
-    ttl: "1h",
-  };
-  return block;
-}